@pie-element/graphing 8.3.4-next.3 → 9.0.0-beta.0

package/controller/lib/utils.js

@@ -1,256 +1,249 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.sortedAnswers = exports.removeInvalidSegments = exports.removeDuplicateSegments = exports.equalVector = exports.equalSine = exports.equalSegment = exports.equalRay = exports.equalPolygon = exports.equalPoint = exports.equalParabola = exports.equalMarks = exports.equalLine = exports.equalExponential = exports.equalCircle = exports.equalAbsolute = exports.constructSegmentsFromPoints = void 0;
-
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
 var _isEqual = _interopRequireDefault(require("lodash/isEqual"));
-
 var _lodash = _interopRequireDefault(require("lodash"));
-
 var _uniqWith = _interopRequireDefault(require("lodash/uniqWith"));
-
 var _differenceWith = _interopRequireDefault(require("lodash/differenceWith"));
-
 var _graphingUtils = require("@pie-lib/graphing-utils");
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-
-var equalPoint = function equalPoint(A, B) {
+const equalPoint = (A, B) => {
   // x1 = x2 & y1 = y2
-  var equalLabel = true;
-  A = _objectSpread({}, A);
-  B = _objectSpread({}, B);
-
+  let equalLabel = true;
+  A = {
+    ...A
+  };
+  B = {
+    ...B
+  };
   if (A.label || B.label) {
-    equalLabel = (0, _isEqual["default"])(A.label, B.label);
+    equalLabel = (0, _isEqual.default)(A.label, B.label);
   }
-
-  return (0, _isEqual["default"])(A.x, B.x) && (0, _isEqual["default"])(A.y, B.y);
+  return (0, _isEqual.default)(A.x, B.x) && (0, _isEqual.default)(A.y, B.y);
 };
-
 exports.equalPoint = equalPoint;
-
-var equalSegment = function equalSegment(segment1, segment2) {
+const equalSegment = (segment1, segment2) => {
   // A.from = B.from, A.to = B.to OR A.from = B.to, A.to = B.from
   // x1 = x3 & y1 = y3 & x2 = x4 & y2 = y4
-  return (0, _isEqual["default"])(segment1.from, segment2.from) && (0, _isEqual["default"])(segment1.to, segment2.to) || (0, _isEqual["default"])(segment1.to, segment2.from) && (0, _isEqual["default"])(segment1.from, segment2.to);
+  return (0, _isEqual.default)(segment1.from, segment2.from) && (0, _isEqual.default)(segment1.to, segment2.to) || (0, _isEqual.default)(segment1.to, segment2.from) && (0, _isEqual.default)(segment1.from, segment2.to);
 };
-
 exports.equalSegment = equalSegment;
-
-var equalVector = function equalVector(vector1, vector2) {
+const equalVector = (vector1, vector2) => {
   // A.from = B.from, A.to = B.to;
   // x1 = x3 & y1 = y3 & x2 = x4 & y2 = y4
-  return (0, _isEqual["default"])(vector1.from, vector2.from) && (0, _isEqual["default"])(vector1.to, vector2.to);
-}; // this function is implemented in configure as well
-
-
-exports.equalVector = equalVector;
-
-var sortedAnswers = function sortedAnswers(answers) {
-  return Object.keys(answers || {}).sort().reduce(function (result, key) {
-    if (key !== 'correctAnswer') {
-      result[key] = answers[key];
-    }
-
-    return result;
-  }, {});
+  return (0, _isEqual.default)(vector1.from, vector2.from) && (0, _isEqual.default)(vector1.to, vector2.to);
 };
 
+// this function is implemented in configure as well
+exports.equalVector = equalVector;
+const sortedAnswers = answers => Object.keys(answers || {}).sort().reduce((result, key) => {
+  if (key !== 'correctAnswer') {
+    result[key] = answers[key];
+  }
+  return result;
+}, {});
 exports.sortedAnswers = sortedAnswers;
-
-var returnLineEquationCoefficients = function returnLineEquationCoefficients(line) {
-  line = _objectSpread(_objectSpread({}, line), {}, {
-    to: _objectSpread({}, line.to),
-    from: _objectSpread({}, line.from)
-  });
-  var xA = line.from.x;
-  var yA = line.from.y;
-  var xB = line.to.x;
-  var yB = line.to.y;
+const returnLineEquationCoefficients = line => {
+  line = {
+    ...line,
+    to: {
+      ...line.to
+    },
+    from: {
+      ...line.from
+    }
+  };
+  const xA = line.from.x;
+  const yA = line.from.y;
+  const xB = line.to.x;
+  const yB = line.to.y;
   return {
     a: yB - yA,
     b: xA - xB,
     c: xB * yA - xA * yB
   };
 };
-
-var getSignificantDecimals = function getSignificantDecimals(number) {
-  return Math.round(number * 10000) / 10000;
-};
-
-var equalLine = function equalLine(line1, line2) {
+const getSignificantDecimals = number => Math.round(number * 10000) / 10000;
+const equalLine = (line1, line2) => {
   // line equation: ax + by + c = 0
   // 2 lines are equal if a1/a2 = b1/b2 = c1/c2, where a, b, c are the coefficients in line equation
+
   // line equation knowing 2 points: (y - yA) / (yB - yA) = (x - xA) / (xB - xA)
   // extending this equation, we get: x * (yB - yA) + y * (xA - xB) + (xB * yA - xA * yB) = 0
   // where a = yB - yA; b = xA - xB; c = xB * yA - xA * yB
-  var _returnLineEquationCo = returnLineEquationCoefficients(line1),
-      a1 = _returnLineEquationCo.a,
-      b1 = _returnLineEquationCo.b,
-      c1 = _returnLineEquationCo.c;
-
-  var _returnLineEquationCo2 = returnLineEquationCoefficients(line2),
-      a2 = _returnLineEquationCo2.a,
-      b2 = _returnLineEquationCo2.b,
-      c2 = _returnLineEquationCo2.c;
-
-  var proportions = [];
 
+  const {
+    a: a1,
+    b: b1,
+    c: c1
+  } = returnLineEquationCoefficients(line1);
+  const {
+    a: a2,
+    b: b2,
+    c: c2
+  } = returnLineEquationCoefficients(line2);
+  const proportions = [];
   if (a2 !== 0) {
     proportions.push(getSignificantDecimals(a1 / a2));
   } else if (a1 !== a2) {
     return false;
   }
-
   if (b2 !== 0) {
     proportions.push(getSignificantDecimals(b1 / b2));
   } else if (b1 !== b2) {
     return false;
   }
-
   if (c2 !== 0) {
     proportions.push(getSignificantDecimals(c1 / c2));
   } else if (c1 !== c2) {
     return false;
   }
+  return _lodash.default.uniq(proportions).length === 1;
 
-  return _lodash["default"].uniq(proportions).length === 1; // (y2 - y1)/(x2 - x1) = (y4 - y3)/(x4 - x3);
+  // (y2 - y1)/(x2 - x1) = (y4 - y3)/(x4 - x3);
   // return ((Math.abs((line1.to.y - line1.from.y) / (line1.to.x - line1.from.x))) === (Math.abs((line2.to.y - line2.from.y) / (line2.to.x - line2.from.x))));
 };
-
 exports.equalLine = equalLine;
+const equalRay = (ray1, ray2) => {
+  ray1 = {
+    ...ray1,
+    to: {
+      ...ray1.to
+    },
+    from: {
+      ...ray1.from
+    }
+  };
+  ray2 = {
+    ...ray2,
+    to: {
+      ...ray2.to
+    },
+    from: {
+      ...ray2.from
+    }
+  };
 
-var equalRay = function equalRay(ray1, ray2) {
-  ray1 = _objectSpread(_objectSpread({}, ray1), {}, {
-    to: _objectSpread({}, ray1.to),
-    from: _objectSpread({}, ray1.from)
-  });
-  ray2 = _objectSpread(_objectSpread({}, ray2), {}, {
-    to: _objectSpread({}, ray2.to),
-    from: _objectSpread({}, ray2.from)
-  }); // slope: m = (y2-y1)/(x2-x1)
+  // slope: m = (y2-y1)/(x2-x1)
   // slope & x1 = x3 & y1 = y3 & angle between (x1, y1) (x2, y2) is same as angle between (x3, y3) (x4, y4)
-
-  var mRay1 = (ray1.to.y - ray1.from.y) / (ray1.to.x - ray1.from.x);
-  var mRay2 = (ray2.to.y - ray2.from.y) / (ray2.to.x - ray2.from.x);
-  var angleRay1 = Math.atan2(ray1.to.y - ray1.from.y, ray1.to.x - ray1.from.x) * 180 / Math.PI;
-  var angleRay2 = Math.atan2(ray2.to.y - ray2.from.y, ray2.to.x - ray2.from.x) * 180 / Math.PI;
+  const mRay1 = (ray1.to.y - ray1.from.y) / (ray1.to.x - ray1.from.x);
+  const mRay2 = (ray2.to.y - ray2.from.y) / (ray2.to.x - ray2.from.x);
+  const angleRay1 = Math.atan2(ray1.to.y - ray1.from.y, ray1.to.x - ray1.from.x) * 180 / Math.PI;
+  const angleRay2 = Math.atan2(ray2.to.y - ray2.from.y, ray2.to.x - ray2.from.x) * 180 / Math.PI;
   return mRay1 === mRay2 && ray1.from.x === ray2.from.x && ray1.from.y === ray2.from.y && angleRay1 === angleRay2;
 };
-
 exports.equalRay = equalRay;
-
-var constructSegmentsFromPoints = function constructSegmentsFromPoints(points) {
+const constructSegmentsFromPoints = points => {
   // takes the list of points that represent a polygon and transforms it into a list of segments; eg.:
   // points: A, B, C, D => segments: AB, BC, CD, DA
-  return (points || []).map(function (point, index) {
-    return {
-      from: point,
-      to: points[(index + 1) % points.length]
-    };
-  });
+  return (points || []).map((point, index) => ({
+    from: point,
+    to: points[(index + 1) % points.length]
+  }));
 };
-
 exports.constructSegmentsFromPoints = constructSegmentsFromPoints;
-
-var removeDuplicateSegments = function removeDuplicateSegments(segments) {
-  segments = segments || []; // removes segments that are duplicates; eg. These segments are the same, so one will be removed:
+const removeDuplicateSegments = segments => {
+  segments = segments || [];
+  // removes segments that are duplicates; eg. These segments are the same, so one will be removed:
   // segment1: from: { x: 1, y: 1 }, to: { x: 2, y: 1 }
   // segment2: from: { x: 2, y: 1 }, to: { x: 1, y: 1 }
-
-  return (0, _uniqWith["default"])(segments, function (s1, s2) {
-    return equalSegment(s1, s2);
-  });
+  return (0, _uniqWith.default)(segments, (s1, s2) => equalSegment(s1, s2));
 };
-
 exports.removeDuplicateSegments = removeDuplicateSegments;
+const removeInvalidSegments = segments => {
+  segments = segments || [];
+  // removes segments that start in a point and end in the same point (eg.: from: { x: 1, y: 1 }, to: { x: 1, y: 1 })
 
-var removeInvalidSegments = function removeInvalidSegments(segments) {
-  segments = segments || []; // removes segments that start in a point and end in the same point (eg.: from: { x: 1, y: 1 }, to: { x: 1, y: 1 })
-
-  return segments.filter(function (segment) {
-    return !(0, _isEqual["default"])(segment.from, segment.to);
-  });
+  return segments.filter(segment => !(0, _isEqual.default)(segment.from, segment.to));
 };
-
 exports.removeInvalidSegments = removeInvalidSegments;
-
-var equalPolygon = function equalPolygon(poly1, poly2) {
-  var points1 = poly1.points;
-  var points2 = poly2.points; // generate segments
-
-  var segments1 = constructSegmentsFromPoints(points1);
-  var segments2 = constructSegmentsFromPoints(points2);
-  var segments1NoDuplicates = removeDuplicateSegments(removeInvalidSegments(segments1));
-  var segments2NoDuplicates = removeDuplicateSegments(removeInvalidSegments(segments2));
-  var differentSegments1 = (0, _differenceWith["default"])(segments1NoDuplicates, segments2NoDuplicates, equalSegment);
-  var differentSegments2 = (0, _differenceWith["default"])(segments2NoDuplicates, segments1NoDuplicates, equalSegment);
+const equalPolygon = (poly1, poly2) => {
+  const {
+    points: points1
+  } = poly1;
+  const {
+    points: points2
+  } = poly2;
+
+  // generate segments
+  const segments1 = constructSegmentsFromPoints(points1);
+  const segments2 = constructSegmentsFromPoints(points2);
+  const segments1NoDuplicates = removeDuplicateSegments(removeInvalidSegments(segments1));
+  const segments2NoDuplicates = removeDuplicateSegments(removeInvalidSegments(segments2));
+  const differentSegments1 = (0, _differenceWith.default)(segments1NoDuplicates, segments2NoDuplicates, equalSegment);
+  const differentSegments2 = (0, _differenceWith.default)(segments2NoDuplicates, segments1NoDuplicates, equalSegment);
   return (!differentSegments1 || !differentSegments1.length) && (!differentSegments2 || !differentSegments2.length);
 };
-
 exports.equalPolygon = equalPolygon;
+const equalCircle = (c1, c2) => {
+  c1 = {
+    ...c1,
+    root: {
+      ...c1.root
+    },
+    edge: {
+      ...c1.edge
+    }
+  };
+  c2 = {
+    ...c2,
+    root: {
+      ...c2.root
+    },
+    edge: {
+      ...c2.edge
+    }
+  };
+  const equalRootAndEdge = (0, _isEqual.default)(c2.edge, c1.edge) && (0, _isEqual.default)(c2.root, c1.root);
 
-var equalCircle = function equalCircle(c1, c2) {
-  c1 = _objectSpread(_objectSpread({}, c1), {}, {
-    root: _objectSpread({}, c1.root),
-    edge: _objectSpread({}, c1.edge)
-  });
-  c2 = _objectSpread(_objectSpread({}, c2), {}, {
-    root: _objectSpread({}, c2.root),
-    edge: _objectSpread({}, c2.edge)
-  });
-  var equalRootAndEdge = (0, _isEqual["default"])(c2.edge, c1.edge) && (0, _isEqual["default"])(c2.root, c1.root); // if both edge and root are the same, it means the shapes are exactly the same
-
+  // if both edge and root are the same, it means the shapes are exactly the same
   if (equalRootAndEdge) return true;
-  var rC1 = Math.sqrt(Math.pow(c1.edge.x - c1.root.x, 2) + Math.pow(c1.edge.y - c1.root.y, 2));
-  var rC2 = Math.sqrt(Math.pow(c2.edge.x - c2.root.x, 2) + Math.pow(c2.edge.y - c2.root.y, 2)); // if both root and radius are the same, it means the shapes are equal
+  const rC1 = Math.sqrt((c1.edge.x - c1.root.x) ** 2 + (c1.edge.y - c1.root.y) ** 2);
+  const rC2 = Math.sqrt((c2.edge.x - c2.root.x) ** 2 + (c2.edge.y - c2.root.y) ** 2);
 
-  return (0, _isEqual["default"])(c2.root, c1.root) && (0, _isEqual["default"])(rC1, rC2);
+  // if both root and radius are the same, it means the shapes are equal
+  return (0, _isEqual.default)(c2.root, c1.root) && (0, _isEqual.default)(rC1, rC2);
 };
-
 exports.equalCircle = equalCircle;
-
-var equalSine = function equalSine(sine1, sine2) {
-  var getPoints = function getPoints(_ref) {
-    var root = _ref.root,
-        edge = _ref.edge;
-    root = _objectSpread({}, root);
-    edge = _objectSpread({}, edge);
-
-    var _getAmplitudeAndFreq = (0, _graphingUtils.getAmplitudeAndFreq)(root, edge),
-        amplitude = _getAmplitudeAndFreq.amplitude,
-        freq = _getAmplitudeAndFreq.freq; // the height of the sine wave
-
-
-    var tY = Math.abs(root.y - edge.y) * 2; // the distance on x axis between edge and root
-
-    var tXRoot = Math.abs(root.x - edge.x); // the distance on x axis between 2 edges for sine wave (min & max)
-
-    var tX = tXRoot * 2; // the first edge placed east side of root
-
-    var edgeAboveZeroX = edge.x;
-    var edgeAboveZeroY = edge.y; // if edge less then 0, find out the appropriate edge placed east side of zero (0)
-
+const equalSine = (sine1, sine2) => {
+  const getPoints = ({
+    root,
+    edge
+  }) => {
+    root = {
+      ...root
+    };
+    edge = {
+      ...edge
+    };
+    const {
+      amplitude,
+      freq
+    } = (0, _graphingUtils.getAmplitudeAndFreq)(root, edge);
+    // the height of the sine wave
+    const tY = Math.abs(root.y - edge.y) * 2;
+    // the distance on x axis between edge and root
+    const tXRoot = Math.abs(root.x - edge.x);
+    // the distance on x axis between 2 edges for sine wave (min & max)
+    const tX = tXRoot * 2;
+    // the first edge placed east side of root
+    let edgeAboveZeroX = edge.x;
+    let edgeAboveZeroY = edge.y;
+
+    // if edge less then 0, find out the appropriate edge placed east side of zero (0)
     while (edgeAboveZeroX < 0 && tX !== 0) {
       edgeAboveZeroX = edgeAboveZeroX + tX;
       edgeAboveZeroY = edgeAboveZeroY < root.y ? edgeAboveZeroY + tY : edgeAboveZeroY - tY;
-    } // if edge more then 0, find out the appropriate edge placed east side of zero (0)
-
+    }
 
+    // if edge more then 0, find out the appropriate edge placed east side of zero (0)
     while (edgeAboveZeroX - tX > 0 && tX !== 0) {
       edgeAboveZeroX = edgeAboveZeroX - tX;
       edgeAboveZeroY = edgeAboveZeroY < root.y ? edgeAboveZeroY + tY : edgeAboveZeroY - tY;
     }
-
     return {
       amplitude: getSignificantDecimals(amplitude),
       freq: getSignificantDecimals(freq),
@@ -260,183 +253,180 @@ var equalSine = function equalSine(sine1, sine2) {
       edgeAboveZeroY: getSignificantDecimals(edgeAboveZeroY)
     };
   };
-
-  var studentAnswerBpY = getPoints(sine1);
-  var correctAnswerBpY = getPoints(sine2);
-  var amplitude1 = studentAnswerBpY.amplitude,
-      freq1 = studentAnswerBpY.freq,
-      min1 = studentAnswerBpY.min,
-      max1 = studentAnswerBpY.max,
-      edgeAboveZeroX1 = studentAnswerBpY.edgeAboveZeroX,
-      edgeAboveZeroY1 = studentAnswerBpY.edgeAboveZeroY;
-  var amplitude2 = correctAnswerBpY.amplitude,
-      freq2 = correctAnswerBpY.freq,
-      min2 = correctAnswerBpY.min,
-      max2 = correctAnswerBpY.max,
-      edgeAboveZeroX2 = correctAnswerBpY.edgeAboveZeroX,
-      edgeAboveZeroY2 = correctAnswerBpY.edgeAboveZeroY;
-  return Math.abs(amplitude1) === Math.abs(amplitude2) && Math.abs(freq1) === Math.abs(freq2) && min1 === min2 && max1 === max2 && edgeAboveZeroX1 === edgeAboveZeroX2 && edgeAboveZeroY1 === edgeAboveZeroY2; // rootDiff1 === rootDiff2);
+  const studentAnswerBpY = getPoints(sine1);
+  const correctAnswerBpY = getPoints(sine2);
+  const {
+    amplitude: amplitude1,
+    freq: freq1,
+    min: min1,
+    max: max1,
+    edgeAboveZeroX: edgeAboveZeroX1,
+    edgeAboveZeroY: edgeAboveZeroY1
+  } = studentAnswerBpY;
+  const {
+    amplitude: amplitude2,
+    freq: freq2,
+    min: min2,
+    max: max2,
+    edgeAboveZeroX: edgeAboveZeroX2,
+    edgeAboveZeroY: edgeAboveZeroY2
+  } = correctAnswerBpY;
+  return Math.abs(amplitude1) === Math.abs(amplitude2) && Math.abs(freq1) === Math.abs(freq2) && min1 === min2 && max1 === max2 && edgeAboveZeroX1 === edgeAboveZeroX2 && edgeAboveZeroY1 === edgeAboveZeroY2;
+  // rootDiff1 === rootDiff2);
 };
-
 exports.equalSine = equalSine;
-
-var equalParabola = function equalParabola(p1, p2) {
-  var edgeP1 = p1.edge;
-  var edgeP2 = p2.edge;
-  var rootP1 = p1.root;
-  var rootP2 = p2.root;
-  rootP1 = _objectSpread({}, rootP1);
-  rootP2 = _objectSpread({}, rootP2);
-
-  var p1edge = edgeP1 || _objectSpread({}, rootP1);
-
-  var p2edge = edgeP2 || _objectSpread({}, rootP2);
-
-  var p1mirrorEdge = {
+const equalParabola = (p1, p2) => {
+  const {
+    edge: edgeP1
+  } = p1;
+  const {
+    edge: edgeP2
+  } = p2;
+  let {
+    root: rootP1
+  } = p1;
+  let {
+    root: rootP2
+  } = p2;
+  rootP1 = {
+    ...rootP1
+  };
+  rootP2 = {
+    ...rootP2
+  };
+  const p1edge = edgeP1 || {
+    ...rootP1
+  };
+  const p2edge = edgeP2 || {
+    ...rootP2
+  };
+  const p1mirrorEdge = {
     x: rootP1.x - (p1edge.x - rootP1.x),
     y: p1edge.y
   };
-  var p2mirrorEdge = {
+  const p2mirrorEdge = {
     x: rootP2.x - (p2edge.x - rootP2.x),
     y: p2edge.y
   };
   if (!edgeP1 || !edgeP2) return false;
-
-  var _pointsToABC = (0, _graphingUtils.pointsToABC)(rootP1, edgeP1, p1mirrorEdge),
-      a1 = _pointsToABC.a,
-      b1 = _pointsToABC.b,
-      c1 = _pointsToABC.c;
-
-  var _pointsToABC2 = (0, _graphingUtils.pointsToABC)(rootP2, edgeP2, p2mirrorEdge),
-      a2 = _pointsToABC2.a,
-      b2 = _pointsToABC2.b,
-      c2 = _pointsToABC2.c; // sometimes numbers have this form: 1.00000000002 because of calculations, we have to round them
-
-
-  var round = function round(number) {
-    return Math.round(number * 10000) / 10000;
-  };
-
+  const {
+    a: a1,
+    b: b1,
+    c: c1
+  } = (0, _graphingUtils.pointsToABC)(rootP1, edgeP1, p1mirrorEdge);
+  const {
+    a: a2,
+    b: b2,
+    c: c2
+  } = (0, _graphingUtils.pointsToABC)(rootP2, edgeP2, p2mirrorEdge);
+
+  // sometimes numbers have this form: 1.00000000002 because of calculations, we have to round them
+  const round = number => Math.round(number * 10000) / 10000;
   return round(a1) === round(a2) && round(b1) === round(b2) && round(c1) === round(c2);
 };
+
 /*
  * Function to check if given two points for absolute function
  * for correct answer and student answer are equal or not.
  * @param p1 - student answer
  * @param p2 - correct answer
  * */
-
-
 exports.equalParabola = equalParabola;
+const equalAbsolute = (p1, p2) => {
+  const {
+    edge: edgeP1
+  } = p1;
+  const {
+    edge: edgeP2
+  } = p2;
+  let {
+    root: rootP1
+  } = p1;
+  let {
+    root: rootP2
+  } = p2;
+  rootP1 = {
+    ...rootP1
+  };
+  rootP2 = {
+    ...rootP2
+  };
+  const p1edge = edgeP1 || {
+    ...rootP1
+  };
+  const p2edge = edgeP2 || {
+    ...rootP2
+  };
+  const p1a1 = (0, _graphingUtils.pointsToAForAbsolute)(rootP1, p1edge);
+  const p2a2 = (0, _graphingUtils.pointsToAForAbsolute)(rootP2, p2edge);
 
-var equalAbsolute = function equalAbsolute(p1, p2) {
-  var edgeP1 = p1.edge;
-  var edgeP2 = p2.edge;
-  var rootP1 = p1.root;
-  var rootP2 = p2.root;
-  rootP1 = _objectSpread({}, rootP1);
-  rootP2 = _objectSpread({}, rootP2);
-
-  var p1edge = edgeP1 || _objectSpread({}, rootP1);
-
-  var p2edge = edgeP2 || _objectSpread({}, rootP2);
-
-  var p1a1 = (0, _graphingUtils.pointsToAForAbsolute)(rootP1, p1edge);
-  var p2a2 = (0, _graphingUtils.pointsToAForAbsolute)(rootP2, p2edge); // if both root and a value are equal
-
-  return (0, _isEqual["default"])(rootP2, rootP1) && (0, _isEqual["default"])(p2a2, p1a1);
+  // if both root and a value are equal
+  return (0, _isEqual.default)(rootP2, rootP1) && (0, _isEqual.default)(p2a2, p1a1);
 };
+
 /*
  * Function to check if given two points for exponential function
  * for correct answer and student answer are equal or not.
  * @param p1 - student answer
  * @param p2 - correct answer
  * */
-
-
 exports.equalAbsolute = equalAbsolute;
-
-var equalExponential = function equalExponential(p1, p2) {
-  var edgeP1 = p1.edge;
-  var edgeP2 = p2.edge;
-  var rootP1 = p1.root;
-  var rootP2 = p2.root;
-  rootP1 = _objectSpread({}, rootP1);
-  rootP2 = _objectSpread({}, rootP2);
-
-  var p1edge = edgeP1 || _objectSpread({}, rootP1);
-
-  var p2edge = edgeP2 || _objectSpread({}, rootP2);
-
-  var _pointsToABForExponen = (0, _graphingUtils.pointsToABForExponential)(rootP1, p1edge),
-      a1 = _pointsToABForExponen.a1,
-      b1 = _pointsToABForExponen.b1;
-
-  var _pointsToABForExponen2 = (0, _graphingUtils.pointsToABForExponential)(rootP2, p2edge),
-      a2 = _pointsToABForExponen2.a2,
-      b2 = _pointsToABForExponen2.b2; // if both a and b value are equal
-
-
-  return (0, _isEqual["default"])(a2, a1) && (0, _isEqual["default"])(b2, b1);
+const equalExponential = (p1, p2) => {
+  const {
+    edge: edgeP1
+  } = p1;
+  const {
+    edge: edgeP2
+  } = p2;
+  let {
+    root: rootP1
+  } = p1;
+  let {
+    root: rootP2
+  } = p2;
+  rootP1 = {
+    ...rootP1
+  };
+  rootP2 = {
+    ...rootP2
+  };
+  const p1edge = edgeP1 || {
+    ...rootP1
+  };
+  const p2edge = edgeP2 || {
+    ...rootP2
+  };
+  const {
+    a1,
+    b1
+  } = (0, _graphingUtils.pointsToABForExponential)(rootP1, p1edge);
+  const {
+    a2,
+    b2
+  } = (0, _graphingUtils.pointsToABForExponential)(rootP2, p2edge);
+
+  // if both a and b value are equal
+  return (0, _isEqual.default)(a2, a1) && (0, _isEqual.default)(b2, b1);
 };
-
 exports.equalExponential = equalExponential;
-var equalMarks = {
-  circle: function circle(sessAnswer, mark) {
-    return equalCircle(sessAnswer, mark);
-  },
-  line: function line(sessAnswer, mark) {
-    return equalLine(sessAnswer, mark);
-  },
-  parabola: function parabola(sessAnswer, mark) {
-    return equalParabola(sessAnswer, mark);
-  },
-  absolute: function absolute(sessAnswer, mark) {
-    return equalAbsolute(sessAnswer, mark);
-  },
-  exponential: function exponential(sessAnswer, mark) {
-    return equalExponential(sessAnswer, mark);
-  },
-  point: function point(sessAnswer, mark) {
-    return equalPoint(sessAnswer, mark);
-  },
-  polygon: function polygon(sessAnswer, poly) {
-    return equalPolygon(sessAnswer, poly);
-  },
-  ray: function ray(sessAnswer, mark) {
-    return equalRay(sessAnswer, mark);
-  },
-  segment: function segment(sessAnswer, mark) {
-    return equalSegment(sessAnswer, mark);
-  },
-  sine: function sine(sessAnswer, mark) {
-    return equalSine(sessAnswer, mark);
-  },
-  vector: function vector(sessAnswer, mark) {
-    return equalVector(sessAnswer, mark);
-  }
-};
-exports.equalMarks = equalMarks;
-
-var completePoint = function completePoint(point) {
-  return point && Number.isFinite(point.x) && Number.isFinite(point.y);
+const equalMarks = exports.equalMarks = {
+  circle: (sessAnswer, mark) => equalCircle(sessAnswer, mark),
+  line: (sessAnswer, mark) => equalLine(sessAnswer, mark),
+  parabola: (sessAnswer, mark) => equalParabola(sessAnswer, mark),
+  absolute: (sessAnswer, mark) => equalAbsolute(sessAnswer, mark),
+  exponential: (sessAnswer, mark) => equalExponential(sessAnswer, mark),
+  point: (sessAnswer, mark) => equalPoint(sessAnswer, mark),
+  polygon: (sessAnswer, poly) => equalPolygon(sessAnswer, poly),
+  ray: (sessAnswer, mark) => equalRay(sessAnswer, mark),
+  segment: (sessAnswer, mark) => equalSegment(sessAnswer, mark),
+  sine: (sessAnswer, mark) => equalSine(sessAnswer, mark),
+  vector: (sessAnswer, mark) => equalVector(sessAnswer, mark)
 };
-
-var completeFromTo = function completeFromTo(item) {
-  return item && completeMark.point(item.from) && completeMark.point(item.to);
-};
-
-var completeRootEdge = function completeRootEdge(item) {
-  return item && completeMark.point(item.edge) && completeMark.point(item.root);
-};
-
-var completePoints = function completePoints(item) {
-  return item && item.points && item.points.length && (item.points.filter(function (point) {
-    return completePoint(point);
-  }) || []).length === item.points.length;
-};
-
-var completeMark = {
+const completePoint = point => point && Number.isFinite(point.x) && Number.isFinite(point.y);
+const completeFromTo = item => item && completeMark.point(item.from) && completeMark.point(item.to);
+const completeRootEdge = item => item && completeMark.point(item.edge) && completeMark.point(item.root);
+const completePoints = item => item && item.points && item.points.length && (item.points.filter(point => completePoint(point)) || []).length === item.points.length;
+const completeMark = {
   point: completePoint,
   line: completeFromTo,
   ray: completeFromTo,