@complat/react-spectra-editor 1.0.0-rc2 → 1.0.0-rc20.patch-1

package/dist/helpers/multiplicity_complat.js

@@ -5,15 +5,13 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.calcMpyComplat = void 0;
 var _multiplicity = require("./multiplicity");
-var calcMpyComplat = function calcMpyComplat(origPeaks) {
-  var peaks = origPeaks.sort(function (a, b) {
-    return a.x - b.x;
-  });
-  var count = peaks.length;
-  var itvs = (0, _multiplicity.getInterval)(peaks);
-  var gitvs = (0, _multiplicity.groupInterval)(itvs);
-  var type = 'm';
-  var js = [];
+const calcMpyComplat = origPeaks => {
+  const peaks = origPeaks.sort((a, b) => a.x - b.x);
+  const count = peaks.length;
+  const itvs = (0, _multiplicity.getInterval)(peaks);
+  const gitvs = (0, _multiplicity.groupInterval)(itvs);
+  let type = 'm';
+  let js = [];
   switch (count) {
     case 1:
       type = 's';
@@ -22,57 +20,43 @@ var calcMpyComplat = function calcMpyComplat(origPeaks) {
     case 2:
       if (gitvs.length === 1) {
         type = 'd';
-        js = gitvs.map(function (g) {
-          return g.c;
-        });
+        js = gitvs.map(g => g.c);
         break;
       }
       break;
     case 3:
       if (gitvs.length === 1) {
         type = 't';
-        js = gitvs.map(function (g) {
-          return g.c;
-        });
+        js = gitvs.map(g => g.c);
         break;
       }
       break;
     case 4:
       if (gitvs.length === 1) {
         type = 'q';
-        js = gitvs.map(function (g) {
-          return g.c;
-        });
+        js = gitvs.map(g => g.c);
         break;
       } else if (gitvs.length === 2) {
         type = 'dd';
-        js = gitvs.map(function (g) {
-          return g.c;
-        });
+        js = gitvs.map(g => g.c);
         break;
       }
       break;
     case 5:
       if (gitvs.length === 1) {
         type = 'quint';
-        js = gitvs.map(function (g) {
-          return g.c;
-        });
+        js = gitvs.map(g => g.c);
         break;
       }
       break;
     case 6:
       if (gitvs.length === 1) {
         type = 'h';
-        js = gitvs.map(function (g) {
-          return g.c;
-        });
+        js = gitvs.map(g => g.c);
         break;
       } else if (gitvs.length === 2) {
         type = 'dt';
-        js = gitvs.map(function (g) {
-          return g.c;
-        });
+        js = gitvs.map(g => g.c);
         break;
       }
       // td
@@ -80,15 +64,11 @@ var calcMpyComplat = function calcMpyComplat(origPeaks) {
     case 7:
       if (gitvs.length === 1) {
         type = 'sept';
-        js = gitvs.map(function (g) {
-          return g.c;
-        });
+        js = gitvs.map(g => g.c);
         break;
       } else if (gitvs.length === 3) {
         type = 'ddd';
-        js = gitvs.map(function (g) {
-          return g.c;
-        });
+        js = gitvs.map(g => g.c);
         break;
       }
       // td
@@ -96,21 +76,15 @@ var calcMpyComplat = function calcMpyComplat(origPeaks) {
     case 8:
       if (gitvs.length === 1) {
         type = 'o';
-        js = gitvs.map(function (g) {
-          return g.c;
-        });
+        js = gitvs.map(g => g.c);
         break;
       } else if (gitvs.length === 2) {
         type = 'dq';
-        js = gitvs.map(function (g) {
-          return g.c;
-        });
+        js = gitvs.map(g => g.c);
         break;
       } else if (gitvs.length === 3) {
         type = 'ddd';
-        js = gitvs.map(function (g) {
-          return g.c;
-        });
+        js = gitvs.map(g => g.c);
         break;
       }
       // td
@@ -119,8 +93,8 @@ var calcMpyComplat = function calcMpyComplat(origPeaks) {
       break;
   }
   return {
-    type: type,
-    js: js
+    type,
+    js
   };
 };
 exports.calcMpyComplat = calcMpyComplat;

package/dist/helpers/multiplicity_manual.js

@@ -7,112 +7,106 @@ exports.calcMpyManual = void 0;
 var _multiplicity = require("./multiplicity");
 /* eslint-disable prefer-object-spread, default-param-last, no-mixed-operators */
 
-var isTypeM = function isTypeM(mpyType) {
-  return mpyType === 'm';
-};
-var isTypeBasic = function isTypeBasic(mpyType) {
-  return _multiplicity.mpyBasicPatterns.slice(1).indexOf(mpyType) >= 0;
-};
-var outputTypeM = function outputTypeM(k) {
-  return Object.assign({}, k, {
-    mpyType: 'm',
-    js: []
-  });
-};
-var outputTypeBasic = function outputTypeBasic(k, mpyType, ivs, freq) {
-  var numIvs = ivs.length || 1;
-  var js = [freq * ivs.reduce(function (sum, x) {
-    return sum + x;
-  }) / numIvs];
+const isTypeM = mpyType => mpyType === 'm';
+const isTypeBasic = mpyType => _multiplicity.mpyBasicPatterns.slice(1).indexOf(mpyType) >= 0;
+const outputTypeM = k => Object.assign({}, k, {
+  mpyType: 'm',
+  js: []
+});
+const outputTypeBasic = (k, mpyType, ivs, freq) => {
+  const numIvs = ivs.length || 1;
+  const js = [freq * ivs.reduce((sum, x) => sum + x) / numIvs];
   return Object.assign({}, k, {
-    mpyType: mpyType,
-    js: js
+    mpyType,
+    js
   });
 };
-var outputTypeDD = function outputTypeDD(k, mpyType, ivs, freq) {
+const outputTypeDD = (k, mpyType, ivs, freq) => {
   if (ivs.length >= 2) {
-    var js = [freq * ivs[0], freq * (ivs[0] + ivs[1])];
+    const js = [freq * ivs[0], freq * (ivs[0] + ivs[1])];
     return Object.assign({}, k, {
-      mpyType: mpyType,
-      js: js
+      mpyType,
+      js
     });
   }
   return Object.assign({}, k, {
-    mpyType: mpyType,
+    mpyType,
     js: []
   });
 };
-var outputTypeDT = function outputTypeDT(k, mpyType, ivs, freq) {
+const outputTypeDT = (k, mpyType, ivs, freq) => {
   if (ivs.length >= 4) {
-    var js = [freq * ivs[0], freq * (ivs[1] + ivs[2] + ivs[3])];
+    const js = [freq * ivs[0], freq * (ivs[1] + ivs[2] + ivs[3])];
     return Object.assign({}, k, {
-      mpyType: mpyType,
-      js: js
+      mpyType,
+      js
     });
   }
   return Object.assign({}, k, {
-    mpyType: mpyType,
+    mpyType,
     js: []
   });
 };
-var outputTypeTD = function outputTypeTD(k, mpyType, ivs, freq) {
+const outputTypeTD = (k, mpyType, ivs, freq) => {
   if (ivs.length >= 2) {
-    var js = [freq * ivs[0], freq * (ivs[0] + ivs[1])];
+    const js = [freq * ivs[0], freq * (ivs[0] + ivs[1])];
     return Object.assign({}, k, {
-      mpyType: mpyType,
-      js: js
+      mpyType,
+      js
     });
   }
   return Object.assign({}, k, {
-    mpyType: mpyType,
+    mpyType,
     js: []
   });
 };
-var outputTypeDQ = function outputTypeDQ(k, mpyType, ivs, freq) {
+const outputTypeDQ = (k, mpyType, ivs, freq) => {
   if (ivs.length >= 2) {
-    var js = [freq * ivs[0], freq * (ivs[0] + ivs[1])];
+    const js = [freq * ivs[0], freq * (ivs[0] + ivs[1])];
     return Object.assign({}, k, {
-      mpyType: mpyType,
-      js: js
+      mpyType,
+      js
     });
   } // only consider J = ([1,2], [1,3]), not J = ([1,2], [1,5])
   return Object.assign({}, k, {
-    mpyType: mpyType,
+    mpyType,
     js: []
   });
 };
-var outputTypeQD = function outputTypeQD(k, mpyType, ivs, freq) {
+const outputTypeQD = (k, mpyType, ivs, freq) => {
   if (ivs.length >= 2) {
-    var js = [freq * ivs[0], freq * (ivs[0] + ivs[1])];
+    const js = [freq * ivs[0], freq * (ivs[0] + ivs[1])];
     return Object.assign({}, k, {
-      mpyType: mpyType,
-      js: js
+      mpyType,
+      js
     });
   }
   return Object.assign({}, k, {
-    mpyType: mpyType,
+    mpyType,
     js: []
   });
 };
-var outputTypeDDD = function outputTypeDDD(k, mpyType, ivs, freq) {
+const outputTypeDDD = (k, mpyType, ivs, freq) => {
   if (ivs.length >= 3) {
-    var js = [freq * ivs[0], freq * (ivs[0] + ivs[1]), freq * (ivs[0] + ivs[1] + ivs[2] + ivs[3])];
+    const js = [freq * ivs[0], freq * (ivs[0] + ivs[1]), freq * (ivs[0] + ivs[1] + ivs[2] + ivs[3])];
     return Object.assign({}, k, {
-      mpyType: mpyType,
-      js: js
+      mpyType,
+      js
     });
   }
   return Object.assign({}, k, {
-    mpyType: mpyType,
+    mpyType,
     js: []
   });
 };
-var calcMpyManual = function calcMpyManual(k, mpyType, metaSt) {
-  var observeFrequency = metaSt.peaks.observeFrequency;
-  var freq = observeFrequency || 1.0;
-  var ivs = (0, _multiplicity.getInterval)(k.peaks);
+const calcMpyManual = (k, mpyType, metaSt) => {
+  const {
+    observeFrequency
+  } = metaSt.peaks;
+  const freq = observeFrequency || 1.0;
+  const ivs = (0, _multiplicity.getInterval)(k.peaks);
   if (ivs.length === 0) return Object.assign({}, k, {
-    mpyType: mpyType,
+    mpyType,
     js: []
   });
   if (isTypeM(mpyType)) return outputTypeM(k);
@@ -124,7 +118,7 @@ var calcMpyManual = function calcMpyManual(k, mpyType, metaSt) {
   if (mpyType === 'qd') return outputTypeQD(k, mpyType, ivs, freq);
   if (mpyType === 'ddd') return outputTypeDDD(k, mpyType, ivs, freq);
   return Object.assign({}, k, {
-    mpyType: mpyType,
+    mpyType,
     js: []
   });
 };

package/dist/helpers/multiplicity_verify_basic.js

@@ -1,37 +1,35 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.verifyTypeT = exports.verifyTypeSept = exports.verifyTypeQuint = exports.verifyTypeQ = exports.verifyTypePeakCount = exports.verifyTypeO = exports.verifyTypeH = void 0;
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 /* eslint-disable prefer-object-spread, default-param-last, no-mixed-operators */
 // ---------------------------------------------------------------
 // verifyTypePeakCount
 // ---------------------------------------------------------------
 
-var verifyTypePeakCount = function verifyTypePeakCount(type, peaks) {
-  var isBasicWrong = type === 's' && peaks.length > 1 || type === 'd' && peaks.length > 2 || type === 't' && peaks.length > 3 || type === 'q' && peaks.length > 4 || type === 'quint' && peaks.length > 5 || type === 'h' && peaks.length > 6 || type === 'sept' && peaks.length > 7 || type === 'o' && peaks.length > 8 || type === 'n' && peaks.length > 9;
-  var limit = 1;
-  var mStr = type;
-  limit *= Math.pow(5, (mStr.match(/quint/g) || []).length);
+const verifyTypePeakCount = (type, peaks) => {
+  const isBasicWrong = type === 's' && peaks.length > 1 || type === 'd' && peaks.length > 2 || type === 't' && peaks.length > 3 || type === 'q' && peaks.length > 4 || type === 'quint' && peaks.length > 5 || type === 'h' && peaks.length > 6 || type === 'sept' && peaks.length > 7 || type === 'o' && peaks.length > 8 || type === 'n' && peaks.length > 9;
+  let limit = 1;
+  let mStr = type;
+  limit *= 5 ** (mStr.match(/quint/g) || []).length;
   mStr = mStr.replace(/quint/g, '');
-  limit *= Math.pow(7, (mStr.match(/sept/g) || []).length);
+  limit *= 7 ** (mStr.match(/sept/g) || []).length;
   mStr = mStr.replace(/sept/g, '');
-  limit *= Math.pow(2, (mStr.match(/d/g) || []).length);
+  limit *= 2 ** (mStr.match(/d/g) || []).length;
   mStr = mStr.replace(/d/g, '');
-  limit *= Math.pow(3, (mStr.match(/t/g) || []).length);
+  limit *= 3 ** (mStr.match(/t/g) || []).length;
   mStr = mStr.replace(/t/g, '');
-  limit *= Math.pow(4, (mStr.match(/q/g) || []).length);
+  limit *= 4 ** (mStr.match(/q/g) || []).length;
   mStr = mStr.replace(/q/g, '');
-  limit *= Math.pow(6, (mStr.match(/h/g) || []).length);
+  limit *= 6 ** (mStr.match(/h/g) || []).length;
   mStr = mStr.replace(/h/g, '');
-  limit *= Math.pow(8, (mStr.match(/o/g) || []).length);
+  limit *= 8 ** (mStr.match(/o/g) || []).length;
   mStr = mStr.replace(/o/g, '');
-  limit *= Math.pow(9, (mStr.match(/n/g) || []).length);
+  limit *= 9 ** (mStr.match(/n/g) || []).length;
   mStr = mStr.replace(/n/g, '');
-  var isAdvanWrong = peaks.length > limit;
+  const isAdvanWrong = peaks.length > limit;
   return !(isBasicWrong || isAdvanWrong);
 };
 
@@ -39,47 +37,41 @@ var verifyTypePeakCount = function verifyTypePeakCount(type, peaks) {
 // Basic Multiplicity verification
 // ---------------------------------------------------------------
 exports.verifyTypePeakCount = verifyTypePeakCount;
-var allowedTolerance = 0.15;
-var faktor = 1.1;
-var passRuleIntervalCounts = function passRuleIntervalCounts(oivs, limit) {
-  return oivs.length === limit;
-};
-var getRuleParams = function getRuleParams(oivs, metaSt) {
-  var _metaSt$peaks = metaSt.peaks,
-    deltaX = _metaSt$peaks.deltaX,
-    observeFrequency = _metaSt$peaks.observeFrequency;
-  var sivs = (0, _toConsumableArray2.default)(oivs).sort(function (a, b) {
-    return b - a;
-  });
-  var ref = sivs[0];
-  var rDeltaX = Math.abs(2 * deltaX / ref);
-  var tTolerance = rDeltaX > allowedTolerance ? rDeltaX : allowedTolerance;
-  var tolerance = Math.abs(tTolerance * faktor);
-  var roivs = oivs.map(function (oiv) {
-    return oiv / ref;
-  });
-  var rsivs = sivs.map(function (siv) {
-    return siv / ref;
-  });
+const allowedTolerance = 0.15;
+const faktor = 1.1;
+const passRuleIntervalCounts = (oivs, limit) => oivs.length === limit;
+const getRuleParams = (oivs, metaSt) => {
+  const {
+    deltaX,
+    observeFrequency
+  } = metaSt.peaks;
+  const sivs = [...oivs].sort((a, b) => b - a);
+  const ref = sivs[0];
+  const rDeltaX = Math.abs(2 * deltaX / ref);
+  const tTolerance = rDeltaX > allowedTolerance ? rDeltaX : allowedTolerance;
+  const tolerance = Math.abs(tTolerance * faktor);
+  const roivs = oivs.map(oiv => oiv / ref);
+  const rsivs = sivs.map(siv => siv / ref);
   return {
-    roivs: roivs,
-    rsivs: rsivs,
-    tolerance: tolerance,
-    observeFrequency: observeFrequency
+    roivs,
+    rsivs,
+    tolerance,
+    observeFrequency
   };
 };
-var verifyTypeT = function verifyTypeT(type, js, oivs, metaSt) {
+const verifyTypeT = (type, js, oivs, metaSt) => {
   if (!passRuleIntervalCounts(oivs, 2)) return {
     type: 'm',
     js: []
   };
-  var _getRuleParams = getRuleParams(oivs, metaSt),
-    rsivs = _getRuleParams.rsivs,
-    tolerance = _getRuleParams.tolerance;
-  var isT = Math.abs(rsivs[0] - rsivs[1]) < tolerance;
+  const {
+    rsivs,
+    tolerance
+  } = getRuleParams(oivs, metaSt);
+  const isT = Math.abs(rsivs[0] - rsivs[1]) < tolerance;
   if (isT) return {
-    type: type,
-    js: js
+    type,
+    js
   };
   return {
     type: 'm',
@@ -87,23 +79,24 @@ var verifyTypeT = function verifyTypeT(type, js, oivs, metaSt) {
   };
 };
 exports.verifyTypeT = verifyTypeT;
-var verifyTypeQ = function verifyTypeQ(type, js, oivs, metaSt) {
+const verifyTypeQ = (type, js, oivs, metaSt) => {
   if (!passRuleIntervalCounts(oivs, 3)) return {
     type: 'm',
     js: []
   };
-  var _getRuleParams2 = getRuleParams(oivs, metaSt),
-    roivs = _getRuleParams2.roivs,
-    rsivs = _getRuleParams2.rsivs,
-    tolerance = _getRuleParams2.tolerance,
-    observeFrequency = _getRuleParams2.observeFrequency;
-  var isQ = Math.abs(rsivs[0] - rsivs[2]) < tolerance;
+  const {
+    roivs,
+    rsivs,
+    tolerance,
+    observeFrequency
+  } = getRuleParams(oivs, metaSt);
+  const isQ = Math.abs(rsivs[0] - rsivs[2]) < tolerance;
   if (isQ) return {
-    type: type,
-    js: js
+    type,
+    js
   };
-  var isDD = Math.abs(roivs[0] - roivs[2]) < tolerance && Math.abs(roivs[0] - roivs[1]) >= tolerance;
-  var ddJs = [oivs[0] * observeFrequency, (oivs[0] + oivs[1]) * observeFrequency];
+  const isDD = Math.abs(roivs[0] - roivs[2]) < tolerance && Math.abs(roivs[0] - roivs[1]) >= tolerance;
+  const ddJs = [oivs[0] * observeFrequency, (oivs[0] + oivs[1]) * observeFrequency];
   if (isDD) return {
     type: 'dd',
     js: ddJs
@@ -114,18 +107,19 @@ var verifyTypeQ = function verifyTypeQ(type, js, oivs, metaSt) {
   };
 };
 exports.verifyTypeQ = verifyTypeQ;
-var verifyTypeQuint = function verifyTypeQuint(type, js, oivs, metaSt) {
+const verifyTypeQuint = (type, js, oivs, metaSt) => {
   if (!passRuleIntervalCounts(oivs, 4)) return {
     type: 'm',
     js: []
   };
-  var _getRuleParams3 = getRuleParams(oivs, metaSt),
-    rsivs = _getRuleParams3.rsivs,
-    tolerance = _getRuleParams3.tolerance;
-  var isQuint = Math.abs(rsivs[0] - rsivs[3]) < tolerance;
+  const {
+    rsivs,
+    tolerance
+  } = getRuleParams(oivs, metaSt);
+  const isQuint = Math.abs(rsivs[0] - rsivs[3]) < tolerance;
   if (isQuint) return {
-    type: type,
-    js: js
+    type,
+    js
   };
   return {
     type: 'm',
@@ -133,35 +127,36 @@ var verifyTypeQuint = function verifyTypeQuint(type, js, oivs, metaSt) {
   };
 };
 exports.verifyTypeQuint = verifyTypeQuint;
-var verifyTypeH = function verifyTypeH(type, js, oivs, metaSt) {
+const verifyTypeH = (type, js, oivs, metaSt) => {
   if (!passRuleIntervalCounts(oivs, 5)) return {
     type: 'm',
     js: []
   };
-  var _getRuleParams4 = getRuleParams(oivs, metaSt),
-    roivs = _getRuleParams4.roivs,
-    rsivs = _getRuleParams4.rsivs,
-    tolerance = _getRuleParams4.tolerance,
-    observeFrequency = _getRuleParams4.observeFrequency;
-  var isH = Math.abs(rsivs[0] - rsivs[4]) < tolerance;
+  const {
+    roivs,
+    rsivs,
+    tolerance,
+    observeFrequency
+  } = getRuleParams(oivs, metaSt);
+  const isH = Math.abs(rsivs[0] - rsivs[4]) < tolerance;
   if (isH) return {
-    type: type,
-    js: js
+    type,
+    js
   };
-  var isTD = Math.abs(roivs[0] - roivs[2]) < tolerance && Math.abs(roivs[0] - roivs[4]) < tolerance && Math.abs(roivs[1] - roivs[3]) < tolerance && Math.abs(roivs[0] - roivs[1]) >= tolerance;
-  var tdJs = [oivs[0] * observeFrequency, (oivs[0] + oivs[1]) * observeFrequency];
+  const isTD = Math.abs(roivs[0] - roivs[2]) < tolerance && Math.abs(roivs[0] - roivs[4]) < tolerance && Math.abs(roivs[1] - roivs[3]) < tolerance && Math.abs(roivs[0] - roivs[1]) >= tolerance;
+  const tdJs = [oivs[0] * observeFrequency, (oivs[0] + oivs[1]) * observeFrequency];
   if (isTD) return {
     type: 'td',
     js: tdJs
   };
-  var isDT1 = Math.abs(roivs[0] - roivs[1]) < tolerance && Math.abs(roivs[0] - roivs[3]) < tolerance && Math.abs(roivs[0] - roivs[4]) < tolerance && Math.abs(roivs[0] - roivs[2]) >= tolerance;
-  var dt1Js = [oivs[0] * observeFrequency, (oivs[1] + oivs[2] + oivs[3]) * observeFrequency];
+  const isDT1 = Math.abs(roivs[0] - roivs[1]) < tolerance && Math.abs(roivs[0] - roivs[3]) < tolerance && Math.abs(roivs[0] - roivs[4]) < tolerance && Math.abs(roivs[0] - roivs[2]) >= tolerance;
+  const dt1Js = [oivs[0] * observeFrequency, (oivs[1] + oivs[2] + oivs[3]) * observeFrequency];
   if (isDT1) return {
     type: 'dt',
     js: dt1Js
   };
-  var isDT2 = Math.abs(roivs[0] - roivs[4]) < tolerance && Math.abs(roivs[0] - roivs[1] - roivs[2]) < tolerance && Math.abs(roivs[0] - roivs[2] - roivs[3]) < tolerance && Math.abs(roivs[0] - roivs[2]) >= tolerance;
-  var dt2Js = [oivs[0] * observeFrequency, (oivs[1] + oivs[2] + oivs[3]) * observeFrequency];
+  const isDT2 = Math.abs(roivs[0] - roivs[4]) < tolerance && Math.abs(roivs[0] - roivs[1] - roivs[2]) < tolerance && Math.abs(roivs[0] - roivs[2] - roivs[3]) < tolerance && Math.abs(roivs[0] - roivs[2]) >= tolerance;
+  const dt2Js = [oivs[0] * observeFrequency, (oivs[1] + oivs[2] + oivs[3]) * observeFrequency];
   if (isDT2) return {
     type: 'dt',
     js: dt2Js
@@ -172,23 +167,24 @@ var verifyTypeH = function verifyTypeH(type, js, oivs, metaSt) {
   };
 };
 exports.verifyTypeH = verifyTypeH;
-var verifyTypeSept = function verifyTypeSept(type, js, oivs, metaSt) {
+const verifyTypeSept = (type, js, oivs, metaSt) => {
   if (!passRuleIntervalCounts(oivs, 6)) return {
     type: 'm',
     js: []
   };
-  var _getRuleParams5 = getRuleParams(oivs, metaSt),
-    roivs = _getRuleParams5.roivs,
-    rsivs = _getRuleParams5.rsivs,
-    tolerance = _getRuleParams5.tolerance,
-    observeFrequency = _getRuleParams5.observeFrequency;
-  var isSept = Math.abs(rsivs[0] - rsivs[5]) < tolerance;
+  const {
+    roivs,
+    rsivs,
+    tolerance,
+    observeFrequency
+  } = getRuleParams(oivs, metaSt);
+  const isSept = Math.abs(rsivs[0] - rsivs[5]) < tolerance;
   if (isSept) return {
-    type: type,
-    js: js
+    type,
+    js
   };
-  var isDDD = Math.abs(roivs[0] - roivs[2]) < tolerance && Math.abs(roivs[0] - roivs[3]) < tolerance && Math.abs(roivs[0] - roivs[5]) < tolerance && Math.abs(roivs[1] - roivs[4]) < tolerance && Math.abs(roivs[0] - roivs[1]) >= tolerance;
-  var dddJs = [oivs[0] * observeFrequency, (oivs[0] + oivs[1]) * observeFrequency, (oivs[0] + oivs[1] + oivs[2]) * observeFrequency];
+  const isDDD = Math.abs(roivs[0] - roivs[2]) < tolerance && Math.abs(roivs[0] - roivs[3]) < tolerance && Math.abs(roivs[0] - roivs[5]) < tolerance && Math.abs(roivs[1] - roivs[4]) < tolerance && Math.abs(roivs[0] - roivs[1]) >= tolerance;
+  const dddJs = [oivs[0] * observeFrequency, (oivs[0] + oivs[1]) * observeFrequency, (oivs[0] + oivs[1] + oivs[2]) * observeFrequency];
   if (isDDD) return {
     type: 'ddd',
     js: dddJs
@@ -199,47 +195,48 @@ var verifyTypeSept = function verifyTypeSept(type, js, oivs, metaSt) {
   };
 };
 exports.verifyTypeSept = verifyTypeSept;
-var verifyTypeO = function verifyTypeO(type, js, oivs, metaSt) {
+const verifyTypeO = (type, js, oivs, metaSt) => {
   if (!passRuleIntervalCounts(oivs, 7)) return {
     type: 'm',
     js: []
   };
-  var _getRuleParams6 = getRuleParams(oivs, metaSt),
-    roivs = _getRuleParams6.roivs,
-    rsivs = _getRuleParams6.rsivs,
-    tolerance = _getRuleParams6.tolerance,
-    observeFrequency = _getRuleParams6.observeFrequency;
-  var isO = Math.abs(rsivs[0] - rsivs[6]) < tolerance;
+  const {
+    roivs,
+    rsivs,
+    tolerance,
+    observeFrequency
+  } = getRuleParams(oivs, metaSt);
+  const isO = Math.abs(rsivs[0] - rsivs[6]) < tolerance;
   if (isO) return {
-    type: type,
-    js: js
+    type,
+    js
   };
-  var isQD = Math.abs(roivs[0] - roivs[2]) < tolerance && Math.abs(roivs[0] - roivs[4]) < tolerance && Math.abs(roivs[0] - roivs[6]) < tolerance && Math.abs(roivs[1] - roivs[3]) < tolerance && Math.abs(roivs[1] - roivs[5]) < tolerance;
-  var qdJs = [oivs[0] * observeFrequency, (oivs[0] + oivs[1]) * observeFrequency];
+  const isQD = Math.abs(roivs[0] - roivs[2]) < tolerance && Math.abs(roivs[0] - roivs[4]) < tolerance && Math.abs(roivs[0] - roivs[6]) < tolerance && Math.abs(roivs[1] - roivs[3]) < tolerance && Math.abs(roivs[1] - roivs[5]) < tolerance;
+  const qdJs = [oivs[0] * observeFrequency, (oivs[0] + oivs[1]) * observeFrequency];
   if (isQD) return {
     type: 'qd',
     js: qdJs
   };
-  var isDQ1 = Math.abs(roivs[0] - roivs[1] - roivs[2]) < tolerance && Math.abs(roivs[0] - roivs[2] - roivs[3]) < tolerance && Math.abs(roivs[0] - roivs[3] - roivs[4]) < tolerance && Math.abs(roivs[0] - roivs[4] - roivs[5]) < tolerance && Math.abs(roivs[0] - roivs[6]) < tolerance && Math.abs(roivs[1] - roivs[5]) < tolerance;
-  var dq1Js = [oivs[0] * observeFrequency, (oivs[0] + oivs[1]) * observeFrequency];
+  const isDQ1 = Math.abs(roivs[0] - roivs[1] - roivs[2]) < tolerance && Math.abs(roivs[0] - roivs[2] - roivs[3]) < tolerance && Math.abs(roivs[0] - roivs[3] - roivs[4]) < tolerance && Math.abs(roivs[0] - roivs[4] - roivs[5]) < tolerance && Math.abs(roivs[0] - roivs[6]) < tolerance && Math.abs(roivs[1] - roivs[5]) < tolerance;
+  const dq1Js = [oivs[0] * observeFrequency, (oivs[0] + oivs[1]) * observeFrequency];
   if (isDQ1) return {
     type: 'dq',
     js: dq1Js
   };
-  var isDQ2 = Math.abs(roivs[0] - roivs[1]) < tolerance && Math.abs(roivs[0] - roivs[2]) < tolerance && Math.abs(roivs[0] - roivs[4]) < tolerance && Math.abs(roivs[0] - roivs[5]) < tolerance && Math.abs(roivs[0] - roivs[6]) < tolerance && Math.abs(roivs[0] - roivs[3]) >= tolerance;
-  var dq2Js = [oivs[0] * observeFrequency, (oivs[0] + oivs[1] + oivs[2] + oivs[3]) * observeFrequency];
+  const isDQ2 = Math.abs(roivs[0] - roivs[1]) < tolerance && Math.abs(roivs[0] - roivs[2]) < tolerance && Math.abs(roivs[0] - roivs[4]) < tolerance && Math.abs(roivs[0] - roivs[5]) < tolerance && Math.abs(roivs[0] - roivs[6]) < tolerance && Math.abs(roivs[0] - roivs[3]) >= tolerance;
+  const dq2Js = [oivs[0] * observeFrequency, (oivs[0] + oivs[1] + oivs[2] + oivs[3]) * observeFrequency];
   if (isDQ2) return {
     type: 'dq',
     js: dq2Js
   };
-  var isDDD1 = Math.abs(roivs[0] - roivs[2]) < tolerance && Math.abs(roivs[0] - roivs[4]) < tolerance && Math.abs(roivs[0] - roivs[6]) < tolerance && Math.abs(roivs[1] - roivs[5]) < tolerance;
-  var ddd1Js = [oivs[0] * observeFrequency, (oivs[0] + oivs[1]) * observeFrequency, (oivs[0] + oivs[1] + oivs[2] + oivs[3]) * observeFrequency];
+  const isDDD1 = Math.abs(roivs[0] - roivs[2]) < tolerance && Math.abs(roivs[0] - roivs[4]) < tolerance && Math.abs(roivs[0] - roivs[6]) < tolerance && Math.abs(roivs[1] - roivs[5]) < tolerance;
+  const ddd1Js = [oivs[0] * observeFrequency, (oivs[0] + oivs[1]) * observeFrequency, (oivs[0] + oivs[1] + oivs[2] + oivs[3]) * observeFrequency];
   if (isDDD1) return {
     type: 'ddd',
     js: ddd1Js
   };
-  var isDDD2 = Math.abs(roivs[0] - roivs[2] - roivs[3]) < tolerance && Math.abs(roivs[0] - roivs[3] - roivs[4]) < tolerance && Math.abs(roivs[0] - roivs[6]) < tolerance && Math.abs(roivs[1] - roivs[5]) < tolerance && Math.abs(roivs[0] - roivs[1]) >= tolerance;
-  var ddd2Js = [oivs[0] * observeFrequency, (oivs[0] + oivs[1]) * observeFrequency, (oivs[0] + oivs[1] + oivs[2]) * observeFrequency];
+  const isDDD2 = Math.abs(roivs[0] - roivs[2] - roivs[3]) < tolerance && Math.abs(roivs[0] - roivs[3] - roivs[4]) < tolerance && Math.abs(roivs[0] - roivs[6]) < tolerance && Math.abs(roivs[1] - roivs[5]) < tolerance && Math.abs(roivs[0] - roivs[1]) >= tolerance;
+  const ddd2Js = [oivs[0] * observeFrequency, (oivs[0] + oivs[1]) * observeFrequency, (oivs[0] + oivs[1] + oivs[2]) * observeFrequency];
   if (isDDD2) return {
     type: 'ddd',
     js: ddd2Js