@pie-element/number-line 11.0.1 → 11.0.2-esm.0

package/esm/controller.js

@@ -10,55 +10,22 @@ import uniqWith from 'lodash/uniqWith';
 import isObject$1 from 'lodash/isObject';
 import isNumber$1 from 'lodash/isNumber';
 
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
-  try {
-    var info = gen[key](arg);
-    var value = info.value;
-  } catch (error) {
-    reject(error);
-    return;
-  }
-
-  if (info.done) {
-    resolve(value);
-  } else {
-    Promise.resolve(value).then(_next, _throw);
-  }
-}
+function _extends$7() {
+  _extends$7 = Object.assign || function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
 
-function _asyncToGenerator(fn) {
-  return function () {
-    var self = this,
-        args = arguments;
-    return new Promise(function (resolve, reject) {
-      var gen = fn.apply(self, args);
-
-      function _next(value) {
-        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
-      }
-
-      function _throw(err) {
-        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
       }
+    }
 
-      _next(undefined);
-    });
+    return target;
   };
-}
 
-function _defineProperty$2(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value: value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-
-  return obj;
+  return _extends$7.apply(this, arguments);
 }
 
 var DEFAULT_CONFIG = {
@@ -26439,9 +26406,9 @@ var createPow = /* #__PURE__ */factory(name$2E, dependencies$2E, function (_ref)
   }
 });
 
-function ownKeys$4(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+function ownKeys$1(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
 
-function _objectSpread$4(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$4(Object(source), true).forEach(function (key) { _defineProperty$1(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$4(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+function _objectSpread$1(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$1(Object(source), true).forEach(function (key) { _defineProperty$1(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$1(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 
 function _defineProperty$1(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 var NO_INT = 'Number of decimals in function round must be an integer';
@@ -26501,7 +26468,7 @@ var createRound = /* #__PURE__ */factory(name$2D, dependencies$2D, function (_re
    * @return {number | BigNumber | Fraction | Complex | Array | Matrix} Rounded value
    */
 
-  return typed(name$2D, _objectSpread$4(_objectSpread$4({}, roundNumberSignatures), {}, {
+  return typed(name$2D, _objectSpread$1(_objectSpread$1({}, roundNumberSignatures), {}, {
     Complex: function Complex(x) {
       return x.round();
     },
@@ -31712,9 +31679,9 @@ function _typeof$6(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "func
 
 function _extends$5() { _extends$5 = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends$5.apply(this, arguments); }
 
-function ownKeys$3(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
 
-function _objectSpread$3(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$3(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$3(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 var name$25 = 'Unit';
@@ -32395,7 +32362,7 @@ var createUnitClass = /* #__PURE__ */factory(name$25, dependencies$25, function
 
     for (var _i = 0; _i < other.units.length; _i++) {
       // Make a shallow copy of every unit
-      var inverted = _objectSpread$3({}, other.units[_i]);
+      var inverted = _objectSpread({}, other.units[_i]);
 
       res.units.push(inverted);
     } // If at least one operand has a value, then the result should also have a value
@@ -32431,7 +32398,7 @@ var createUnitClass = /* #__PURE__ */factory(name$25, dependencies$25, function
 
     for (var _i2 = 0; _i2 < other.units.length; _i2++) {
       // Make a shallow copy of every unit
-      var inverted = _objectSpread$3(_objectSpread$3({}, other.units[_i2]), {}, {
+      var inverted = _objectSpread(_objectSpread({}, other.units[_i2]), {}, {
         power: -other.units[_i2].power
       });
 
@@ -61620,20 +61587,16 @@ var defaults = {
   widthEnabled: true
 };
 
-function ownKeys$2(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$2(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$2(Object(source), !0).forEach(function (key) { _defineProperty$2(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$2(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-
 /*This will store the possible decimal tick values*/
 
-var decimalTickValues = [0.001, 0.01, 0.02, 0.04, 0.05, 0.1, 0.125, 0.2, 0.25, 0.5];
+const decimalTickValues = [0.001, 0.01, 0.02, 0.04, 0.05, 0.1, 0.125, 0.2, 0.25, 0.5];
 /*This will store the possible fraction tick values*/
 
-var fractionTickValues = ['1/1000', '1/100', '1/64', '1/50', '1/32', '1/25', '1/20', '1/16', '1/15', '1/12', '1/10', '1/9', '1/8', '1/7', '1/6', '1/5', '1/4', '1/3', '1/2'];
+const fractionTickValues = ['1/1000', '1/100', '1/64', '1/50', '1/32', '1/25', '1/20', '1/16', '1/15', '1/12', '1/10', '1/9', '1/8', '1/7', '1/6', '1/5', '1/4', '1/3', '1/2'];
 /*This const will store possible multiplier for label interval that needs to be multiplied
 with tick interval with denominator represented with object key.*/
 
-var labelMultiplier = {
+const labelMultiplier = {
   1: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
   2: [1, 2, 4, 6, 8, 10],
   3: [1, 3, 6, 9],
@@ -61656,8 +61619,8 @@ var labelMultiplier = {
   1000: [1, 2, 4, 5, 8, 10]
 };
 
-var fractionRange = (start, end, interval) => {
-  var m = mod(abs(start), abs(interval));
+const fractionRange = (start, end, interval) => {
+  const m = mod(abs(start), abs(interval));
 
   if (!equal(m, 0)) {
     throw new Error('start point must be divisible by interval');
@@ -61667,8 +61630,8 @@ var fractionRange = (start, end, interval) => {
     return [];
   }
 
-  var e = subtract(end, mod(end, abs(interval)));
-  var direction = larger(interval, 0) ? 'positive' : 'negative';
+  const e = subtract(end, mod(end, abs(interval)));
+  const direction = larger(interval, 0) ? 'positive' : 'negative';
 
   if (direction === 'negative' && largerEq(end, start)) {
     throw new Error('start must be > than end when doing a negative decrement');
@@ -61678,9 +61641,9 @@ var fractionRange = (start, end, interval) => {
     throw new Error('start must be < end when doing increments');
   }
 
-  var compareFn = direction === 'positive' ? smallerEq : equal(e, end) ? largerEq : larger;
-  var out = [];
-  var next = start;
+  const compareFn = direction === 'positive' ? smallerEq : equal(e, end) ? largerEq : larger;
+  const out = [];
+  let next = start;
 
   while (compareFn(next, e)) {
     out.push(next);
@@ -61690,28 +61653,28 @@ var fractionRange = (start, end, interval) => {
   return out;
 };
 
-var zbrErrorMessage = (start, end) => "Can only do a positive or negative range, but got: start: ".concat(start, " and end:").concat(end);
+const zbrErrorMessage = (start, end) => `Can only do a positive or negative range, but got: start: ${start} and end:${end}`;
 
-var zeroBasedRange = (start, end, interval) => {
+const zeroBasedRange = (start, end, interval) => {
   start = fraction$1(start);
   end = fraction$1(end);
   interval = fraction$1(interval);
-  var length = abs(subtract(end, start));
+  const length = abs(subtract(end, start));
 
   if (larger(length, abs(end))) {
     throw new Error(zbrErrorMessage(start, end));
   }
 
-  var a = {
+  const a = {
     start: abs(start),
     end: abs(end),
     interval: abs(interval),
     multiplier: smaller(interval, 0) ? -1 : 1
   };
-  var m = mod(a.start, a.interval);
-  var s = larger(m, 0) ? add(subtract(a.start, m), a.interval) : a.start;
-  var r = fractionRange(s, a.end, a.interval);
-  var out = a.multiplier === -1 ? r.map(v => multiply(v, -1)) : r;
+  const m = mod(a.start, a.interval);
+  const s = larger(m, 0) ? add(subtract(a.start, m), a.interval) : a.start;
+  const r = fractionRange(s, a.end, a.interval);
+  const out = a.multiplier === -1 ? r.map(v => multiply(v, -1)) : r;
 
   if (smaller(interval, 0)) {
     out.reverse();
@@ -61720,13 +61683,13 @@ var zeroBasedRange = (start, end, interval) => {
   return out;
 };
 
-var fmin = (a, b) => {
+const fmin = (a, b) => {
   a = fraction$1(a);
   b = fraction$1(b);
   return smaller(a, b) ? a : b;
 };
 
-var fmax = (a, b) => {
+const fmax = (a, b) => {
   a = fraction$1(a);
   b = fraction$1(b);
   return larger(a, b) ? a : b;
@@ -61738,25 +61701,25 @@ var fmax = (a, b) => {
  */
 
 
-var simpleRange = (start, end, interval) => {
+const simpleRange = (start, end, interval) => {
   start = fraction$1(start);
   end = fraction$1(end);
   interval = fraction$1(interval);
-  var positiveRange = larger(end, 0) ? zeroBasedRange(fmax(0, start), end, interval) : [];
-  var negativeRange = smaller(start, 0) ? zeroBasedRange(fmin(0, end), start, multiply(interval, -1)) : [];
-  var together = negativeRange.concat(positiveRange);
-  var out = uniqWith(together, equal);
+  const positiveRange = larger(end, 0) ? zeroBasedRange(fmax(0, start), end, interval) : [];
+  const negativeRange = smaller(start, 0) ? zeroBasedRange(fmin(0, end), start, multiply(interval, -1)) : [];
+  let together = negativeRange.concat(positiveRange);
+  const out = uniqWith(together, equal);
   return out;
 };
 
-var closeTo$1 = (a, b, precision) => {
+const closeTo$1 = (a, b, precision) => {
   precision = precision || 2;
-  var expectedDiff = Math.pow(10, -precision) / 2;
-  var receivedDiff = Math.abs(a - b);
+  const expectedDiff = Math.pow(10, -precision) / 2;
+  const receivedDiff = Math.abs(a - b);
   return receivedDiff < expectedDiff;
 };
 
-var limit = (v, min, max) => {
+const limit = (v, min, max) => {
   if (smaller(fraction(v), fraction(min))) {
     return min;
   }
@@ -61774,18 +61737,18 @@ var limit = (v, min, max) => {
  * */
 
 
-var getMinorLimits = (domain, width) => {
-  var end = domain.max - domain.min;
-  var min = number(multiply(10, divide(fraction$1(end), width)));
-  var max = number(multiply(20, min));
+const getMinorLimits = (domain, width) => {
+  const end = domain.max - domain.min;
+  const min = number(multiply(10, divide(fraction$1(end), width)));
+  const max = number(multiply(20, min));
   return {
     min: min,
     max: max
   };
 };
 
-var isMultiple = (multiple, src) => {
-  var mod$1 = mod(multiple, src);
+const isMultiple = (multiple, src) => {
+  const mod$1 = mod(multiple, src);
   return equal(mod$1, 0);
 };
 /**
@@ -61795,7 +61758,7 @@ var isMultiple = (multiple, src) => {
  */
 
 
-var fraction = v => {
+const fraction = v => {
   if (isObject$1(v)) {
     return fraction$1(v.n * v.s, v.d);
   } else if (isNumber$1(v)) {
@@ -61803,16 +61766,16 @@ var fraction = v => {
   }
 };
 
-var normalizeTicks = (domain, width, ticks, opts) => {
-  var useLimit = opts ? opts.limit !== false : true;
-  var minorLimits = getMinorLimits(domain, width);
-  var minor = useLimit ? limit(fraction(ticks.minor), minorLimits.min, minorLimits.max) : fraction(ticks.minor);
-  var major = useLimit ? limit(fraction(ticks.major), minor, multiply(minor, 20)) : fraction(ticks.major);
-  var isMajorMultiple = isMultiple(major, minor);
+const normalizeTicks = (domain, width, ticks, opts) => {
+  const useLimit = opts ? opts.limit !== false : true;
+  const minorLimits = getMinorLimits(domain, width);
+  const minor = useLimit ? limit(fraction(ticks.minor), minorLimits.min, minorLimits.max) : fraction(ticks.minor);
+  const major = useLimit ? limit(fraction(ticks.major), minor, multiply(minor, 20)) : fraction(ticks.major);
+  const isMajorMultiple = isMultiple(major, minor);
 
   if (!isMajorMultiple) {
-    var multiplier = divide(major, minor);
-    var multiplyBy = multiplier <= 2 ? 2 : Math.round(multiplier); // major must be a multiple of minor
+    const multiplier = divide(major, minor);
+    const multiplyBy = multiplier <= 2 ? 2 : Math.round(multiplier); // major must be a multiple of minor
 
     return {
       minor,
@@ -61830,12 +61793,12 @@ var normalizeTicks = (domain, width, ticks, opts) => {
  */
 
 
-var buildTickDataAsFractions = (domain, width, ticks, opts) => {
+const buildTickDataAsFractions = (domain, width, ticks, opts) => {
   ticks = normalizeTicks(domain, width, ticks, opts);
-  var rng = simpleRange(domain.min, domain.max, ticks.minor);
-  var o = rng.filter(x => smallerEq(x, fraction$1(domain.max))).map(x => {
-    var type = 'minor';
-    var modulo = mod(x, ticks.major);
+  const rng = simpleRange(domain.min, domain.max, ticks.minor);
+  const o = rng.filter(x => smallerEq(x, fraction$1(domain.max))).map(x => {
+    let type = 'minor';
+    const modulo = mod(x, ticks.major);
 
     if (closeTo$1(number(modulo), 0)) {
       type = 'major';
@@ -61855,8 +61818,8 @@ var buildTickDataAsFractions = (domain, width, ticks, opts) => {
  * */
 
 
-var generateMinorValues = minorLimits => {
-  var out = {
+const generateMinorValues = minorLimits => {
+  let out = {
     fraction: [],
     decimal: []
   };
@@ -61866,7 +61829,7 @@ var generateMinorValues = minorLimits => {
     }
   });
   fractionTickValues.forEach(value => {
-    var decimalValue = number(fraction$1(value));
+    let decimalValue = number(fraction$1(value));
 
     if (decimalValue >= minorLimits.min && decimalValue <= minorLimits.max) {
       out.fraction.push(value);
@@ -61882,24 +61845,24 @@ var generateMinorValues = minorLimits => {
  * @return out object containing three arrays 1. fraction values, 2. decimal values,
  * */
 
-var generateMajorValuesForMinor = (minor, domain, width) => {
-  var out = {
+const generateMajorValuesForMinor = (minor, domain, width) => {
+  let out = {
     decimal: [],
     fraction: []
   };
-  var fraction = fraction$1(number(number(minor)));
-  var n = fraction.n;
-  var d = fraction.d;
+  let fraction = fraction$1(number(number(minor)));
+  let n = fraction.n;
+  let d = fraction.d;
 
   if (n >= 1 && d === 1) {
-    for (var i = 1; i <= 10; i++) {
-      var num = number(multiply(n, i)); //Here we check if this major value can plot at least 2 points on number line.
+    for (let i = 1; i <= 10; i++) {
+      let num = number(multiply(n, i)); //Here we check if this major value can plot at least 2 points on number line.
 
-      var ticksData = {
+      let ticksData = {
         minor: minor,
         major: num
       };
-      var output = buildTickData(domain, width, ticksData, {
+      let output = buildTickData(domain, width, ticksData, {
         fraction: undefined
       });
 
@@ -61909,27 +61872,25 @@ var generateMajorValuesForMinor = (minor, domain, width) => {
       }
     }
   } else {
-    for (var multiplierKey in labelMultiplier[d]) {
-      var _num = multiply(fraction$1(n, d), labelMultiplier[d][multiplierKey]); //Here we check if this major value can plot at least 2 points on number line.
+    for (const multiplierKey in labelMultiplier[d]) {
+      let num = multiply(fraction$1(n, d), labelMultiplier[d][multiplierKey]); //Here we check if this major value can plot at least 2 points on number line.
 
-
-      var _ticksData = {
+      let ticksData = {
         minor: minor,
-        major: number(_num)
+        major: number(num)
       };
-
-      var _output = buildTickData(domain, width, _ticksData, {
+      let output = buildTickData(domain, width, ticksData, {
         fraction: undefined
       });
 
-      if (_output.filter(x => x.type === 'major').length > 1) {
-        if (_num.d !== 1) {
-          out.fraction.push(_num.n + '/' + _num.d);
+      if (output.filter(x => x.type === 'major').length > 1) {
+        if (num.d !== 1) {
+          out.fraction.push(num.n + '/' + num.d);
         } else {
-          out.fraction.push(_num.n.toString());
+          out.fraction.push(num.n.toString());
         }
 
-        out.decimal.push(number(_num));
+        out.decimal.push(number(num));
       }
     }
   }
@@ -61937,17 +61898,14 @@ var generateMajorValuesForMinor = (minor, domain, width) => {
   return out;
 };
 
-var buildTickData = (domain, width, ticks, opts) => {
-  var result = buildTickDataAsFractions(domain, width, ticks, opts);
-  var out = result.map(o => opts.fraction ? o : _objectSpread$2(_objectSpread$2({}, o), {}, {
+const buildTickData = (domain, width, ticks, opts) => {
+  const result = buildTickDataAsFractions(domain, width, ticks, opts);
+  const out = result.map(o => opts.fraction ? o : _extends$7({}, o, {
     x: number(o.x) || 0
   }));
   return out;
 };
 
-function ownKeys$1(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$1(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$1(Object(source), !0).forEach(function (key) { _defineProperty$2(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$1(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 /*
  * This function is duplicated in configure/main.js
  * This function will update major value whenever minor value is changed or tick type is changed
@@ -61955,16 +61913,16 @@ function _objectSpread$1(target) { for (var i = 1; i < arguments.length; i++) {
  * @return graph object with updated ticks values
  * */
 
-var updateMajorValue = graph => {
-  var {
+const updateMajorValue = graph => {
+  const {
     domain,
     ticks,
     width
   } = graph;
-  var majorValues = generateMajorValuesForMinor(ticks.minor, domain, width);
+  const majorValues = generateMajorValuesForMinor(ticks.minor, domain, width);
 
   if (majorValues.decimal.indexOf(ticks.major) === -1) {
-    var currIndex = 0;
+    let currIndex = 0;
 
     if (ticks.tickIntervalType === 'Integer') {
       currIndex = majorValues.decimal.length > 4 ? 4 : majorValues.decimal.length - 1;
@@ -61976,7 +61934,7 @@ var updateMajorValue = graph => {
   }
 
   graph.fraction = ticks.tickIntervalType === 'Fraction' && ticks.major < 1;
-  return _objectSpread$1(_objectSpread$1({}, graph), {}, {
+  return _extends$7({}, graph, {
     ticks
   });
 };
@@ -61989,8 +61947,8 @@ var updateMajorValue = graph => {
  * */
 
 
-var reloadTicksData = graph => {
-  var {
+const reloadTicksData = graph => {
+  const {
     domain,
     ticks = {},
     width
@@ -62006,7 +61964,7 @@ var reloadTicksData = graph => {
   // to different tick types object
 
 
-  var minorLimits = getMinorLimits(domain, width);
+  const minorLimits = getMinorLimits(domain, width);
 
   if (minorLimits.min >= 1) {
     /*
@@ -62025,37 +61983,36 @@ var reloadTicksData = graph => {
       ticks.tickIntervalType = 'Fraction';
     }
 
-    var _minorValues = generateMinorValues(minorLimits);
-
-    var minValue = number(fraction$1(_minorValues.fraction[0]));
-    var maxValue = number(fraction$1(_minorValues.fraction[_minorValues.fraction.length - 1]));
+    const minorValues = generateMinorValues(minorLimits);
+    let minValue = number(fraction$1(minorValues.fraction[0]));
+    let maxValue = number(fraction$1(minorValues.fraction[minorValues.fraction.length - 1]));
 
     if (ticks.minor < minValue || ticks.minor > maxValue) {
       switch (ticks.tickIntervalType) {
         case 'Fraction':
-          ticks.minor = number(fraction$1(_minorValues.fraction[_minorValues.fraction.length - 1]));
-          ticks.fractionTick = _minorValues.fraction[_minorValues.fraction.length - 1];
-          ticks.decimalTick = _minorValues.decimal[0];
+          ticks.minor = number(fraction$1(minorValues.fraction[minorValues.fraction.length - 1]));
+          ticks.fractionTick = minorValues.fraction[minorValues.fraction.length - 1];
+          ticks.decimalTick = minorValues.decimal[0];
           break;
 
         case 'Decimal':
         case 'Integer':
-          ticks.minor = _minorValues.decimal[_minorValues.decimal.length - 1];
-          ticks.decimalTick = _minorValues.decimal[_minorValues.decimal.length - 1];
-          ticks.fractionTick = _minorValues.fraction[0];
+          ticks.minor = minorValues.decimal[minorValues.decimal.length - 1];
+          ticks.decimalTick = minorValues.decimal[minorValues.decimal.length - 1];
+          ticks.fractionTick = minorValues.fraction[0];
       }
     } else {
       switch (ticks.tickIntervalType) {
         case 'Fraction':
-          var fraction = fraction$1(number(ticks.minor));
+          let fraction = fraction$1(number(ticks.minor));
           ticks.fractionTick = fraction.n + '/' + fraction.d;
-          ticks.decimalTick = ticks.decimalTick ? ticks.decimalTick : _minorValues.decimal[0];
+          ticks.decimalTick = ticks.decimalTick ? ticks.decimalTick : minorValues.decimal[0];
           break;
 
         case 'Decimal':
         case 'Integer':
           ticks.decimalTick = ticks.minor;
-          ticks.fractionTick = ticks.fractionTick ? ticks.fractionTick : _minorValues.fraction[0];
+          ticks.fractionTick = ticks.fractionTick ? ticks.fractionTick : minorValues.fraction[0];
       }
     }
 
@@ -62064,7 +62021,7 @@ var reloadTicksData = graph => {
     /*
      * In this scenario all integer, decimal or fraction tick will be enabled
      * */
-    var _minorValues2 = generateMinorValues(minorLimits);
+    const minorValues = generateMinorValues(minorLimits);
 
     if (!(ticks.minor >= minorLimits.min && ticks.minor <= minorLimits.max)) {
       if (minorLimits.min > 0.5) {
@@ -62075,58 +62032,52 @@ var reloadTicksData = graph => {
         case 'Integer':
           ticks.minor = number(ceil(minorLimits.min));
           ticks.integerTick = ticks.minor;
-          ticks.decimalTick = minorLimits.min > 0.5 ? 0 : _minorValues2.decimal[0];
-          ticks.fractionTick = minorLimits.min > 0.5 ? '0' : _minorValues2.fraction[0];
+          ticks.decimalTick = minorLimits.min > 0.5 ? 0 : minorValues.decimal[0];
+          ticks.fractionTick = minorLimits.min > 0.5 ? '0' : minorValues.fraction[0];
           break;
 
         case 'Decimal':
-          ticks.minor = _minorValues2.decimal[0];
+          ticks.minor = minorValues.decimal[0];
           ticks.integerTick = 1;
           ticks.decimalTick = ticks.minor;
-          ticks.fractionTick = _minorValues2.fraction[0];
+          ticks.fractionTick = minorValues.fraction[0];
           break;
 
         case 'Fraction':
-          ticks.minor = number(fraction$1(_minorValues2.fraction[0]));
+          ticks.minor = number(fraction$1(minorValues.fraction[0]));
           ticks.integerTick = 1;
-          ticks.decimalTick = _minorValues2.decimal[0];
-          ticks.fractionTick = _minorValues2.fraction[0];
+          ticks.decimalTick = minorValues.decimal[0];
+          ticks.fractionTick = minorValues.fraction[0];
       }
     } else {
       switch (ticks.tickIntervalType) {
         case 'Integer':
           ticks.integerTick = ticks.minor;
-          ticks.decimalTick = minorLimits.min > 0.5 ? 0 : _minorValues2.decimal[0];
-          ticks.fractionTick = minorLimits.min > 0.5 ? '0' : _minorValues2.fraction[0];
+          ticks.decimalTick = minorLimits.min > 0.5 ? 0 : minorValues.decimal[0];
+          ticks.fractionTick = minorLimits.min > 0.5 ? '0' : minorValues.fraction[0];
           break;
 
         case 'Decimal':
           ticks.integerTick = 1;
           ticks.decimalTick = ticks.minor;
-          ticks.fractionTick = _minorValues2.fraction[0];
+          ticks.fractionTick = minorValues.fraction[0];
           break;
 
         case 'Fraction':
           ticks.integerTick = 1;
-          ticks.decimalTick = _minorValues2.decimal[0];
-
-          var _fraction = fraction$1(number(ticks.minor));
-
-          ticks.fractionTick = _fraction.n + '/' + _fraction.d;
+          ticks.decimalTick = minorValues.decimal[0];
+          let fraction = fraction$1(number(ticks.minor));
+          ticks.fractionTick = fraction.n + '/' + fraction.d;
       }
     }
   }
 
-  return updateMajorValue(_objectSpread$1(_objectSpread$1({}, graph), {}, {
+  return updateMajorValue(_extends$7({}, graph, {
     ticks
   }));
 };
 
-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) { _defineProperty$2(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 score = number => {
+const score = number => {
   return {
     score: {
       scaled: number
@@ -62134,11 +62085,11 @@ var score = number => {
   };
 };
 
-var getPartialScore = (corrected, ps) => {
-  var {
+const getPartialScore = (corrected, ps) => {
+  const {
     correct
   } = corrected;
-  var rule = ps.find(r => r.numberOfCorrect === correct.length);
+  const rule = ps.find(r => r.numberOfCorrect === correct.length);
 
   if (rule) {
     return 1.0 * (rule.scorePercentage / 100);
@@ -62147,8 +62098,8 @@ var getPartialScore = (corrected, ps) => {
   }
 };
 
-var accumulateAnswer = correctResponse => (total, answer) => {
-  var isCorrectResponse = correctResponse.some(cr => matches(cr)(answer));
+const accumulateAnswer = correctResponse => (total, answer) => {
+  const isCorrectResponse = correctResponse.some(cr => matches(cr)(answer));
   return total + (isCorrectResponse ? 1 : 0);
 };
 /**
@@ -62163,10 +62114,10 @@ function outcome(model, session, env) {
         empty: true
       });
     } else {
-      var partialScoringEnabled = partialScoring.enabled(model, env);
-      var numCorrect = (session.answer || []).reduce(accumulateAnswer(model.correctResponse), 0);
-      var total = model.correctResponse.length;
-      var numIncorrect = 0;
+      const partialScoringEnabled = partialScoring.enabled(model, env);
+      const numCorrect = (session.answer || []).reduce(accumulateAnswer(model.correctResponse), 0);
+      let total = model.correctResponse.length;
+      let numIncorrect = 0;
 
       if ((session.answer || []).length > total) {
         numIncorrect = (session.answer || []).length - total;
@@ -62176,14 +62127,14 @@ function outcome(model, session, env) {
         total = 1;
       }
 
-      var _score = numCorrect < 0 ? 0 : (numCorrect - numIncorrect) / total;
+      let score = numCorrect < 0 ? 0 : (numCorrect - numIncorrect) / total;
 
-      if (_score < 0) {
-        _score = 0;
+      if (score < 0) {
+        score = 0;
       }
 
       resolve({
-        score: partialScoringEnabled ? _score : _score === 1 ? 1 : 0
+        score: partialScoringEnabled ? score : score === 1 ? 1 : 0
       });
     }
   });
@@ -62198,22 +62149,20 @@ function getScore(question, session) {
       });
     } else {
       session.answer = session.answer || [];
-      var corrected = getCorrected(session.answer, cloneDeep(question.correctResponse));
-      var correctness = getCorrectness(corrected);
+      const corrected = getCorrected(session.answer, cloneDeep(question.correctResponse));
+      const correctness = getCorrectness(corrected);
 
       if (correctness === 'correct') {
         resolve(score(1.0));
       } else if (correctness === 'incorrect') {
         resolve(score(0.0));
       } else if (correctness === 'partial') {
-        var {
+        const {
           allowPartialScoring,
-          partialScoring: _partialScoring
+          partialScoring
         } = question;
-
-        var ps = (_partialScoring || []).filter(o => !isEmpty(o));
-
-        var canDoPartialScoring = allowPartialScoring && ps.length > 0;
+        const ps = (partialScoring || []).filter(o => !isEmpty(o));
+        const canDoPartialScoring = allowPartialScoring && ps.length > 0;
 
         if (canDoPartialScoring) {
           resolve(score(getPartialScore(corrected, ps)));
@@ -62230,16 +62179,16 @@ function getScore(question, session) {
     }
   });
 }
-var CLOSE_TO_PRECISION = 3;
-var closeTo = (a, b, precision) => {
+const CLOSE_TO_PRECISION = 3;
+const closeTo = (a, b, precision) => {
   precision = precision || 5;
-  var expectedDiff = Math.pow(10, -precision) / 2;
-  var receivedDiff = Math.abs(a - b);
-  var close = receivedDiff <= expectedDiff;
+  const expectedDiff = Math.pow(10, -precision) / 2;
+  const receivedDiff = Math.abs(a - b);
+  const close = receivedDiff <= expectedDiff;
   return close;
 };
 
-var matches = a => v => {
+const matches = a => v => {
   return isEqualWith(a, v, (v, ov) => {
     if (typeof v === 'number' && typeof ov === 'number') {
       return closeTo(v, ov, CLOSE_TO_PRECISION);
@@ -62247,7 +62196,7 @@ var matches = a => v => {
   });
 };
 
-var getCorrected = (answer, correctResponse) => {
+const getCorrected = (answer, correctResponse) => {
   if (isEmpty(correctResponse) && answer.length > 0) {
     return {
       correct: [],
@@ -62258,12 +62207,12 @@ var getCorrected = (answer, correctResponse) => {
   }
 
   return answer.reduce((acc, a, index) => {
-    var {
+    const {
       correct,
       incorrect,
       notInAnswer
     } = acc;
-    var match = find(notInAnswer, matches(a));
+    const match = find(notInAnswer, matches(a));
 
     if (match) {
       correct.push(index);
@@ -62283,8 +62232,8 @@ var getCorrected = (answer, correctResponse) => {
     notInAnswer: correctResponse
   });
 };
-var getCorrectness = corrected => {
-  var {
+const getCorrectness = corrected => {
+  const {
     incorrect,
     correct,
     notInAnswer,
@@ -62319,16 +62268,15 @@ var getCorrectness = corrected => {
  */
 
 function normalize(question) {
-  var feedback = merge(defaults.feedback, question.feedback);
-  return _objectSpread(_objectSpread(_objectSpread({}, defaults), question), {}, {
+  const feedback = merge(defaults.feedback, question.feedback);
+  return _extends$7({}, defaults, question, {
     feedback
   });
 }
-function createDefaultModel() {
-  var model = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+function createDefaultModel(model = {}) {
   return new Promise(resolve => {
-    var out = _objectSpread(_objectSpread({}, model), {}, {
-      graph: _objectSpread(_objectSpread({}, defaults.graph), model.graph),
+    const out = _extends$7({}, model, {
+      graph: _extends$7({}, defaults.graph, model.graph),
       colorContrast: 'black_on_white'
     });
 
@@ -62336,15 +62284,15 @@ function createDefaultModel() {
   });
 } // this function is duplicated in configure; at some point, use the same shared function
 
-var updateTicks = model => {
-  var {
+const updateTicks = model => {
+  const {
     graph: {
       domain,
       labelStep,
       ticks = {}
     } = {}
   } = model;
-  var {
+  const {
     minor,
     major
   } = ticks;
@@ -62358,7 +62306,7 @@ var updateTicks = model => {
     model.graph.fraction = true;
     ticks.tickIntervalType = 'Fraction'; // update the ticks frequency and label value to match the label step if needed
 
-    var step = evaluate(labelStep);
+    const step = evaluate(labelStep);
 
     if (step !== major) {
       ticks.major = step;
@@ -62374,61 +62322,55 @@ function model(question, session, env) {
     return Promise.reject(new Error('question is null'));
   }
 
-  return new Promise( /*#__PURE__*/function () {
-    var _ref = _asyncToGenerator(function* (resolve, reject) {
-      var normalizedQuestion = yield normalize(question);
-      var normalizedModel = updateTicks(normalizedQuestion); // this function is also called in configure, it is a duplicate to maintain consistency and correctness
-
-      var graph = reloadTicksData(normalizedModel.graph);
-
-      if (graph) {
-        var evaluateMode = env.mode === 'evaluate';
-        var correctResponse = cloneDeep(normalizedQuestion.correctResponse);
-        var corrected = evaluateMode && getCorrected(session ? session.answer || [] : [], correctResponse);
-        var correctness = evaluateMode && getCorrectness(corrected);
-        var {
-          exhibitOnly
-        } = graph;
-        var disabled = env.mode !== 'gather' || exhibitOnly === true;
-        var teacherInstructions = null;
-
-        if (env.role === 'instructor' && (env.mode === 'view' || evaluateMode)) {
-          teacherInstructions = normalizedQuestion.teacherInstructions;
-        }
-
-        var fb = evaluateMode ? getFeedbackForCorrectness(correctness, normalizedQuestion.feedback) : Promise.resolve(undefined);
-        fb.then(feedbackMessage => {
-          var out = {
-            prompt: normalizedQuestion.prompt,
-            teacherInstructions,
-            graph,
-            disabled,
-            corrected,
-            correctResponse: evaluateMode && ['unanswered', 'correct'].indexOf(correctness) === -1 && normalizedQuestion.correctResponse,
-            feedback: feedbackMessage && {
-              type: correctness,
-              message: feedbackMessage
-            },
-            colorContrast: env.accessibility && env.accessibility.colorContrast || 'black_on_white',
-            language: normalizedQuestion.language,
-            extraCSSRules: normalizedQuestion.extraCSSRules
-          };
-          resolve(omitBy(out, v => !v));
-        });
-      } else {
-        reject(new Error('graph is undefined'));
-      }
-    });
-
-    return function (_x, _x2) {
-      return _ref.apply(this, arguments);
-    };
-  }());
+  return new Promise(async (resolve, reject) => {
+    const normalizedQuestion = await normalize(question);
+    const normalizedModel = updateTicks(normalizedQuestion); // this function is also called in configure, it is a duplicate to maintain consistency and correctness
+
+    const graph = reloadTicksData(normalizedModel.graph);
+
+    if (graph) {
+      const evaluateMode = env.mode === 'evaluate';
+      const correctResponse = cloneDeep(normalizedQuestion.correctResponse);
+      const corrected = evaluateMode && getCorrected(session ? session.answer || [] : [], correctResponse);
+      const correctness = evaluateMode && getCorrectness(corrected);
+      const {
+        exhibitOnly
+      } = graph;
+      const disabled = env.mode !== 'gather' || exhibitOnly === true;
+      let teacherInstructions = null;
+
+      if (env.role === 'instructor' && (env.mode === 'view' || evaluateMode)) {
+        teacherInstructions = normalizedQuestion.teacherInstructions;
+      }
+
+      const fb = evaluateMode ? getFeedbackForCorrectness(correctness, normalizedQuestion.feedback) : Promise.resolve(undefined);
+      fb.then(feedbackMessage => {
+        const out = {
+          prompt: normalizedQuestion.prompt,
+          teacherInstructions,
+          graph,
+          disabled,
+          corrected,
+          correctResponse: evaluateMode && ['unanswered', 'correct'].indexOf(correctness) === -1 && normalizedQuestion.correctResponse,
+          feedback: feedbackMessage && {
+            type: correctness,
+            message: feedbackMessage
+          },
+          colorContrast: env.accessibility && env.accessibility.colorContrast || 'black_on_white',
+          language: normalizedQuestion.language,
+          extraCSSRules: normalizedQuestion.extraCSSRules
+        };
+        resolve(omitBy(out, v => !v));
+      });
+    } else {
+      reject(new Error('graph is undefined'));
+    }
+  });
 }
-var createCorrectResponseSession = (question, env) => {
+const createCorrectResponseSession = (question, env) => {
   return new Promise(resolve => {
     if (env.mode !== 'evaluate' && env.role === 'instructor') {
-      var {
+      const {
         correctResponse: answer
       } = question;
       resolve({
@@ -62442,49 +62384,47 @@ var createCorrectResponseSession = (question, env) => {
 }; // remove all html tags
 
 
-var getContent = html => (html || '').replace(/(<(?!img|iframe|source)([^>]+)>)/gi, '');
+const getContent = html => (html || '').replace(/(<(?!img|iframe|source)([^>]+)>)/gi, '');
 
-var validate = function validate() {
-  var model = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  var {
+const validate = (model = {}, config = {}) => {
+  const {
     graph,
     correctResponse
   } = model || {};
-  var {
+  const {
     maxMaxElements = 20,
     numberLineDimensions: {
       min: minWidth = 200,
       max: maxWidth = 800
     } = {}
   } = config || {};
-  var {
+  const {
     width,
     domain,
     maxNumberOfPoints
   } = graph || {};
-  var {
+  const {
     min,
     max
   } = domain || {};
-  var errors = {};
+  const errors = {};
   ['teacherInstructions', 'prompt'].forEach(field => {
     var _config$field;
 
-    if ((_config$field = config[field]) !== null && _config$field !== void 0 && _config$field.required && !getContent(model[field])) {
+    if ((_config$field = config[field]) != null && _config$field.required && !getContent(model[field])) {
       errors[field] = 'This field is required.';
     }
   });
 
   if (width < minWidth || width > maxWidth) {
-    errors.widthError = "Width should be a value between ".concat(minWidth, " and ").concat(maxWidth, ".");
+    errors.widthError = `Width should be a value between ${minWidth} and ${maxWidth}.`;
   }
 
-  var MIN_DOMAIN = -100000;
-  var MAX_DOMAIN = 100000;
+  const MIN_DOMAIN = -100000;
+  const MAX_DOMAIN = 100000;
 
   if (min < MIN_DOMAIN || min > MAX_DOMAIN || max < MIN_DOMAIN || max > MAX_DOMAIN) {
-    errors.domainError = "Min and max values must both be in the range [".concat(MIN_DOMAIN, ", ").concat(MAX_DOMAIN, "].");
+    errors.domainError = `Min and max values must both be in the range [${MIN_DOMAIN}, ${MAX_DOMAIN}].`;
   }
 
   if (min >= max) {
@@ -62492,7 +62432,7 @@ var validate = function validate() {
   }
 
   if (maxNumberOfPoints < 1 || maxNumberOfPoints > maxMaxElements) {
-    errors.pointsError = "Max number of elements should be between 1 and ".concat(maxMaxElements, ".");
+    errors.pointsError = `Max number of elements should be between 1 and ${maxMaxElements}.`;
   }
 
   if (correctResponse && correctResponse.length === 0) {