function _typeof(obj) {
  "@babel/helpers - typeof";

  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
    _typeof = function _typeof(obj) {
      return typeof obj;
    };
  } else {
    _typeof = function _typeof(obj) {
      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
    };
  }

  return _typeof(obj);
}

function _inherits(subClass, superClass) {
  if (typeof superClass !== "function" && superClass !== null) {
    throw new TypeError("Super expression must either be null or a function");
  }

  subClass.prototype = Object.create(superClass && superClass.prototype, {
    constructor: {
      value: subClass,
      writable: true,
      configurable: true
    }
  });
  if (superClass) _setPrototypeOf(subClass, superClass);
}

function _setPrototypeOf(o, p) {
  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
    o.__proto__ = p;
    return o;
  };

  return _setPrototypeOf(o, p);
}

function _createSuper(Derived) {
  var hasNativeReflectConstruct = _isNativeReflectConstruct();

  return function _createSuperInternal() {
    var Super = _getPrototypeOf(Derived),
        result;

    if (hasNativeReflectConstruct) {
      var NewTarget = _getPrototypeOf(this).constructor;

      result = Reflect.construct(Super, arguments, NewTarget);
    } else {
      result = Super.apply(this, arguments);
    }

    return _possibleConstructorReturn(this, result);
  };
}

function _possibleConstructorReturn(self, call) {
  if (call && (_typeof(call) === "object" || typeof call === "function")) {
    return call;
  } else if (call !== void 0) {
    throw new TypeError("Derived constructors may only return object or undefined");
  }

  return _assertThisInitialized(self);
}

function _assertThisInitialized(self) {
  if (self === void 0) {
    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  }

  return self;
}

function _isNativeReflectConstruct() {
  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
  if (Reflect.construct.sham) return false;
  if (typeof Proxy === "function") return true;

  try {
    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
    return true;
  } catch (e) {
    return false;
  }
}

function _getPrototypeOf(o) {
  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
    return o.__proto__ || Object.getPrototypeOf(o);
  };
  return _getPrototypeOf(o);
}

function _classCallCheck(instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
}

function _defineProperties(target, props) {
  for (var i = 0; i < props.length; i++) {
    var descriptor = props[i];
    descriptor.enumerable = descriptor.enumerable || false;
    descriptor.configurable = true;
    if ("value" in descriptor) descriptor.writable = true;
    Object.defineProperty(target, descriptor.key, descriptor);
  }
}

function _createClass(Constructor, protoProps, staticProps) {
  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
  if (staticProps) _defineProperties(Constructor, staticProps);
  return Constructor;
} // import Big from '../js/big.min';


(function () {
  var PackedValue = /*#__PURE__*/function () {
    function PackedValue(value, exp, minExp, maxExp) {
      _classCallCheck(this, PackedValue);

      this.minExp = minExp;
      this.maxExp = maxExp;
      this.value = value;
      this.exp = exp;
    }

    _createClass(PackedValue, [{
      key: "setValue",
      value: function setValue(bigValue) {
        var exp = this.minExp;

        while (bigValue.e >= 3 && exp < this.maxExp) {
          exp += 3;
          bigValue = bigValue.div(1000);
        }

        var value;

        if (bigValue.e < 0) {
          value = bigValue.toFixed(-1 * bigValue.e + 2);
        } else {
          value = bigValue.toFixed(exp + 3);
        }

        if (value.indexOf('.') !== -1) {
          while (value.endsWith('0')) {
            value = value.substring(0, value.length - 1);
          }

          if (value.endsWith('.')) {
            value = value.substring(0, value.length - 1);
          }
        }

        this.value = value;
        this.exp = exp;
      }
    }]);

    return PackedValue;
  }();

  var Concentration = /*#__PURE__*/function (_PackedValue) {
    _inherits(Concentration, _PackedValue);

    var _super = _createSuper(Concentration);

    function Concentration(value, exp) {
      _classCallCheck(this, Concentration);

      return _super.call(this, value, exp, 0, 12);
    }

    return Concentration;
  }(PackedValue);

  var Volume = /*#__PURE__*/function (_PackedValue2) {
    _inherits(Volume, _PackedValue2);

    var _super2 = _createSuper(Volume);

    function Volume(value, exp) {
      _classCallCheck(this, Volume);

      return _super2.call(this, value, exp, 0, 6);
    }

    return Volume;
  }(PackedValue);

  var Mass = /*#__PURE__*/function (_PackedValue3) {
    _inherits(Mass, _PackedValue3);

    var _super3 = _createSuper(Mass);

    function Mass(value, exp) {
      _classCallCheck(this, Mass);

      return _super3.call(this, value, exp, 0, 15);
    }

    return Mass;
  }(PackedValue);

  var VolumeRecon = /*#__PURE__*/function (_PackedValue4) {
    _inherits(VolumeRecon, _PackedValue4);

    var _super4 = _createSuper(VolumeRecon);

    function VolumeRecon(value, exp) {
      _classCallCheck(this, VolumeRecon);

      return _super4.call(this, value, exp, 0, 3);
    }

    return VolumeRecon;
  }(PackedValue);

  var MassRecon = /*#__PURE__*/function (_PackedValue5) {
    _inherits(MassRecon, _PackedValue5);

    var _super5 = _createSuper(MassRecon);

    function MassRecon(value, exp) {
      _classCallCheck(this, MassRecon);

      return _super5.call(this, value, exp, 0, 6);
    }

    return MassRecon;
  }(PackedValue);

  var ConcentrationRecon = /*#__PURE__*/function (_PackedValue6) {
    _inherits(ConcentrationRecon, _PackedValue6);

    var _super6 = _createSuper(ConcentrationRecon);

    function ConcentrationRecon(value, exp) {
      _classCallCheck(this, ConcentrationRecon);

      return _super6.call(this, value, exp, 0, 6);
    }

    return ConcentrationRecon;
  }(PackedValue);

  var ConcentrationCell = /*#__PURE__*/function (_PackedValue7) {
    _inherits(ConcentrationCell, _PackedValue7);

    var _super7 = _createSuper(ConcentrationCell);

    function ConcentrationCell(value, exp) {
      _classCallCheck(this, ConcentrationCell);

      return _super7.call(this, value, exp, 0, 6);
    }

    return ConcentrationCell;
  }(PackedValue);

  var DilutionCalculator = /*#__PURE__*/function () {
    function DilutionCalculator() {
      _classCallCheck(this, DilutionCalculator);
    }

    _createClass(DilutionCalculator, null, [{
      key: "calculate",
      value: function calculate(concentrationStart, volumeStart, concentrationEnd, volumeEnd) {
        concentrationStart.value = concentrationStart.value.trim();
        volumeStart.value = volumeStart.value.trim();
        concentrationEnd.value = concentrationEnd.value.trim();
        volumeEnd.value = volumeEnd.value.trim();
        var invalidNumber = 0;
        var emptyNumber = 0;

        if (concentrationStart.value && (isNaN(concentrationStart.value) || +concentrationStart.value <= 0)) {
          invalidNumber += 1;
          $('#c1').addClass("nonempty_submit");
        } else if (!concentrationStart.value) {
          emptyNumber += 1;
          $('#c1').removeClass("nonempty_submit");
        } else {
          $('#c1').removeClass("nonempty_submit");
        }

        if (volumeStart.value && (isNaN(volumeStart.value) || +volumeStart.value <= 0)) {
          invalidNumber += 1;
          $('#v1').addClass("nonempty_submit");
        } else if (!volumeStart.value) {
          emptyNumber += 1;
          $('#v1').removeClass("nonempty_submit");
        } else {
          $('#v1').removeClass("nonempty_submit");
        }

        if (concentrationEnd.value && (isNaN(concentrationEnd.value) || +concentrationEnd.value <= 0)) {
          invalidNumber += 1;
          $('#c2').addClass("nonempty_submit");
        } else if (!concentrationEnd.value) {
          emptyNumber += 1;
          $('#c2').removeClass("nonempty_submit");
        } else {
          $('#c2').removeClass("nonempty_submit");
        }

        if (volumeEnd.value && (isNaN(volumeEnd.value) || +volumeEnd.value <= 0)) {
          invalidNumber += 1;
          $('#v2').addClass("nonempty_submit");
        } else if (!volumeEnd.value) {
          emptyNumber += 1;
          $('#v2').removeClass("nonempty_submit");
        } else {
          $('#v2').removeClass("nonempty_submit");
        }

        if (emptyNumber > 1) {
          $(".calculator-form input").removeClass("nonempty_submit");
          throw new Error('Please fill in three blanks.');
        }

        if (emptyNumber == 0 && invalidNumber >= 1) {
          $(".calculator-form input").removeClass("nonempty_submit");
          throw new Error('Please leave one item blank.');
        }

        if (invalidNumber) {
          throw new Error('Please enter numbers only.');
        }

        var bigResult;

        if (!concentrationStart.value && volumeStart.value && concentrationEnd.value && volumeEnd.value) {
          bigResult = new Big(concentrationEnd.value).times(Math.pow(10, concentrationEnd.exp)).times(volumeEnd.value).times(Math.pow(10, volumeEnd.exp)).div(volumeStart.value).div(Math.pow(10, volumeStart.exp));
          concentrationStart.setValue(bigResult);
        } else if (concentrationStart.value && !volumeStart.value && concentrationEnd.value && volumeEnd.value) {
          bigResult = new Big(concentrationEnd.value).times(Math.pow(10, concentrationEnd.exp)).times(volumeEnd.value).times(Math.pow(10, volumeEnd.exp)).div(concentrationStart.value).div(Math.pow(10, concentrationStart.exp));
          volumeStart.setValue(bigResult);
        } else if (concentrationStart.value && volumeStart.value && !concentrationEnd.value && volumeEnd.value) {
          bigResult = new Big(concentrationStart.value).times(Math.pow(10, concentrationStart.exp)).times(volumeStart.value).times(Math.pow(10, volumeStart.exp)).div(volumeEnd.value).div(Math.pow(10, volumeEnd.exp));
          concentrationEnd.setValue(bigResult);
        } else if (concentrationStart.value && volumeStart.value && concentrationEnd.value && !volumeEnd.value) {
          bigResult = new Big(concentrationStart.value).times(Math.pow(10, concentrationStart.exp)).times(volumeStart.value).times(Math.pow(10, volumeStart.exp)).div(concentrationEnd.value).div(Math.pow(10, concentrationEnd.exp));
          volumeEnd.setValue(bigResult);
        } else {
          throw new Error('Please leave one item blank.');
        }
      }
    }]);

    return DilutionCalculator;
  }();

  var ReconstitutionCalculator = /*#__PURE__*/function () {
    function ReconstitutionCalculator() {
      _classCallCheck(this, ReconstitutionCalculator);
    }

    _createClass(ReconstitutionCalculator, null, [{
      key: "calculate",
      value: function calculate(volumeRecon, massRecon, concentrationRecon) {
        volumeRecon.value = volumeRecon.value.trim();
        massRecon.value = massRecon.value.trim();
        concentrationRecon.value = concentrationRecon.value.trim();
        var invalidNumber = 0;
        var emptyNumber = 0;

        if (volumeRecon.value && (isNaN(volumeRecon.value) || +volumeRecon.value <= 0)) {
          invalidNumber += 1;
        } else if (!volumeRecon.value) {
          emptyNumber += 1;
        }

        if (massRecon.value && (isNaN(massRecon.value) || +massRecon.value <= 0)) {
          invalidNumber += 1;
        } else if (!massRecon.value) {
          emptyNumber += 1;
        }

        if (concentrationRecon.value && (isNaN(concentrationRecon.value) || +concentrationRecon.value <= 0)) {
          invalidNumber += 1;
        } else if (!concentrationRecon.value) {
          emptyNumber += 1;
        }

        if (emptyNumber > 1) {
          $(".calculator-form input").removeClass("nonempty_submit");
          throw new Error('Please fill in two blanks.');
        }

        if (emptyNumber == 0 && invalidNumber >= 1) {
          $(".calculator-form input").removeClass("nonempty_submit");
          throw new Error('Please leave one item blank.');
        }

        if (invalidNumber) {
          throw new Error('Please enter numbers only.');
        }

        var bigResult;

        if (!volumeRecon.value && massRecon.value && concentrationRecon.value) {
          bigResult = new Big(massRecon.value).times(Math.pow(10, massRecon.exp)).div(concentrationRecon.value).div(Math.pow(10, concentrationRecon.exp));
          volumeRecon.setValue(bigResult);
        } else if (volumeRecon.value && !massRecon.value && concentrationRecon.value) {
          bigResult = new Big(volumeRecon.value).times(Math.pow(10, volumeRecon.exp)).times(concentrationRecon.value).times(Math.pow(10, concentrationRecon.exp));
          massRecon.setValue(bigResult);
        } else if (volumeRecon.value && massRecon.value && !concentrationRecon.value) {
          bigResult = new Big(volumeRecon.value).times(Math.pow(10, volumeRecon.exp)).div(massRecon.value).div(Math.pow(10, massRecon.exp));
          concentrationRecon.setValue(bigResult);
        } else {
          throw new Error('Please leave one item blank.');
        }
      }
    }]);

    return ReconstitutionCalculator;
  }();

  var MolarityCalculator = /*#__PURE__*/function () {
    function MolarityCalculator() {
      _classCallCheck(this, MolarityCalculator);
    }

    _createClass(MolarityCalculator, null, [{
      key: "calculate",
      value: function calculate(mass, concentration, volume, mw) {
        mass.value = mass.value.trim();
        concentration.value = concentration.value.trim();
        volume.value = volume.value.trim();
        mw = mw.trim();
        var invalidNumber = 0;
        var emptyNumber = 0;

        if (mass.value && (isNaN(mass.value) || +mass.value <= 0)) {
          invalidNumber += 1;
          $('#mass').addClass("nonempty_submit");
        } else if (!mass.value) {
          emptyNumber += 1;
          $("#mass").removeClass("nonempty_submit");
        } else {
          $("#mass").removeClass("nonempty_submit");
        }

        if (concentration.value && (isNaN(concentration.value) || +concentration.value <= 0)) {
          invalidNumber += 1;
          $('#concentration').addClass("nonempty_submit");
        } else if (!concentration.value) {
          emptyNumber += 1;
          $('#concentration').removeClass("nonempty_submit");
        } else {
          $('#concentration').removeClass("nonempty_submit");
        }

        if (volume.value && (isNaN(volume.value) || +volume.value <= 0)) {
          invalidNumber += 1;
          $('#volume').addClass("nonempty_submit");
        } else if (!volume.value) {
          emptyNumber += 1;
          $('#volume').removeClass("nonempty_submit");
        } else {
          $('#volume').removeClass("nonempty_submit");
        }

        if (mw && (isNaN(mw) || +mw <= 0)) {
          invalidNumber += 1;
          $('#molarityWeightTxt').addClass("nonempty_submit");
        } else if (!mw) {
          $('#molarityWeightTxt').addClass("nonempty_submit");
          emptyNumber += 1;
          throw new Error('Please enter the Molecular Weight.');
        } else {
          $('#molarityWeightTxt').removeClass("nonempty_submit");
        }

        if (emptyNumber > 1) {
          $(".calculator-form input").removeClass("nonempty_submit");
          throw new Error('Please fill in three blanks.');
        }

        if (emptyNumber == 0 && invalidNumber >= 1) {
          $(".calculator-form input").removeClass("nonempty_submit");
          throw new Error('Please leave one item blank.');
        }

        if (invalidNumber) {
          throw new Error('Please enter numbers only.');
        }

        var mwScale = 1e6;
        var bigResult;

        if (!mass.value && concentration.value && volume.value) {
          bigResult = new Big(concentration.value).times(Math.pow(10, concentration.exp)).times(volume.value).times(Math.pow(10, volume.exp)).times(mw).div(mwScale);
          mass.setValue(bigResult);
        } else if (mass.value && !concentration.value && volume.value) {
          bigResult = new Big(mass.value).times(Math.pow(10, mass.exp)).div(volume.value).div(Math.pow(10, volume.exp)).div(mw).times(mwScale);
          concentration.setValue(bigResult);
        } else if (mass.value && concentration.value && !volume.value) {
          bigResult = new Big(mass.value).times(Math.pow(10, mass.exp)).div(concentration.value).div(Math.pow(10, concentration.exp)).div(mw).times(mwScale);
          volume.setValue(bigResult);
        } else {
          throw new Error('Please leave one item blank.');
        }
      }
    }]);

    return MolarityCalculator;
  }();

  if (typeof module !== 'undefined' && typeof module.exports !== 'undefined') {
    module.exports = {
      Concentration: Concentration,
      Volume: Volume,
      Mass: Mass,
      VolumeRecon: VolumeRecon,
      MassRecon: MassRecon,
      ConcentrationRecon: ConcentrationRecon,
      DilutionCalculator: DilutionCalculator,
      MolarityCalculator: MolarityCalculator,
      ReconstitutionCalculator: ReconstitutionCalculator,
      ConcentrationCell: ConcentrationCell
    };
  } else {
    window.Concentration = Concentration;
    window.Volume = Volume;
    window.Mass = Mass;
    window.VolumeRecon = VolumeRecon;
    window.MassRecon = MassRecon;
    window.ConcentrationRecon = ConcentrationRecon;
    window.DilutionCalculator = DilutionCalculator;
    window.MolarityCalculator = MolarityCalculator;
    window.ReconstitutionCalculator = ReconstitutionCalculator;
    window.ConcentrationCell = ConcentrationCell;
  }
})();

function clearMsg(msgId) {
  $(".calculator-form input").removeClass("nonempty_submit");
  $('#' + msgId).text('');
}