mathjs 8.1.0 → 12.2.1

package/lib/esm/type/unit/Unit.js

@@ -1,24 +1,21 @@
-function _extends() { _extends = 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.apply(this, arguments); }
-
-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(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; }
-
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _extends from "@babel/runtime/helpers/extends";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 import { isComplex, isUnit, typeOf } from '../../utils/is.js';
 import { factory } from '../../utils/factory.js';
+import { memoize } from '../../utils/function.js';
 import { endsWith } from '../../utils/string.js';
 import { clone, hasOwnProperty } from '../../utils/object.js';
 import { createBigNumberPi as createPi } from '../../utils/bignumber/constants.js';
 var name = 'Unit';
-var dependencies = ['?on', 'config', 'addScalar', 'subtract', 'multiplyScalar', 'divideScalar', 'pow', 'abs', 'fix', 'round', 'equal', 'isNumeric', 'format', 'number', 'Complex', 'BigNumber', 'Fraction'];
-export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) => {
+var dependencies = ['?on', 'config', 'addScalar', 'subtractScalar', 'multiplyScalar', 'divideScalar', 'pow', 'abs', 'fix', 'round', 'equal', 'isNumeric', 'format', 'number', 'Complex', 'BigNumber', 'Fraction'];
+export var createUnitClass = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     on,
     config,
     addScalar,
-    subtract,
+    subtractScalar,
     multiplyScalar,
     divideScalar,
     pow,
@@ -28,17 +25,17 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
     equal,
     isNumeric,
     format,
-    number,
+    number: _number,
     Complex,
     BigNumber: _BigNumber,
     Fraction: _Fraction
   } = _ref;
-  var toNumber = number;
+  var toNumber = _number;
   /**
    * A unit can be constructed in the following ways:
    *
-   *     const a = new Unit(value, name)
-   *     const b = new Unit(null, name)
+   *     const a = new Unit(value, valuelessUnit)
+   *     const b = new Unit(null, valuelessUnit)
    *     const c = Unit.parse(str)
    *
    * Example usage:
@@ -51,105 +48,91 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
    * @class Unit
    * @constructor Unit
    * @param {number | BigNumber | Fraction | Complex | boolean} [value]  A value like 5.2
-   * @param {string} [name]   A unit name like "cm" or "inch", or a derived unit of the form: "u1[^ex1] [u2[^ex2] ...] [/ u3[^ex3] [u4[^ex4]]]", such as "kg m^2/s^2", where each unit appearing after the forward slash is taken to be in the denominator. "kg m^2 s^-2" is a synonym and is also acceptable. Any of the units can include a prefix.
+   * @param {string | Unit} valuelessUnit   A unit without value. Can have prefix, like "cm"
    */
-
-  function Unit(value, name) {
+  function Unit(value, valuelessUnit) {
     if (!(this instanceof Unit)) {
       throw new Error('Constructor must be called with the new operator');
     }
-
     if (!(value === null || value === undefined || isNumeric(value) || isComplex(value))) {
       throw new TypeError('First parameter in Unit constructor must be number, BigNumber, Fraction, Complex, or undefined');
     }
-
-    if (name !== undefined && (typeof name !== 'string' || name === '')) {
-      throw new TypeError('Second parameter in Unit constructor must be a string');
-    }
-
-    if (name !== undefined) {
-      var u = Unit.parse(name);
-      this.units = u.units;
-      this.dimensions = u.dimensions;
-    } else {
-      this.units = [{
-        unit: UNIT_NONE,
-        prefix: PREFIXES.NONE,
-        // link to a list with supported prefixes
-        power: 0
-      }];
-      this.dimensions = [];
-
-      for (var i = 0; i < BASE_DIMENSIONS.length; i++) {
-        this.dimensions[i] = 0;
-      }
-    }
-
-    this.value = value !== undefined && value !== null ? this._normalize(value) : null;
     this.fixPrefix = false; // if true, function format will not search for the
     // best prefix but leave it as initially provided.
     // fixPrefix is set true by the method Unit.to
-    // The justification behind this is that if the constructor is explicitly called,
-    // the caller wishes the units to be returned exactly as he supplied.
 
+    // The justification behind this is that if the constructor is explicitly called,
+    // the caller wishes the units to be returned exactly as supplied.
     this.skipAutomaticSimplification = true;
+    if (valuelessUnit === undefined) {
+      this.units = [];
+      this.dimensions = BASE_DIMENSIONS.map(x => 0);
+    } else if (typeof valuelessUnit === 'string') {
+      var u = Unit.parse(valuelessUnit);
+      this.units = u.units;
+      this.dimensions = u.dimensions;
+    } else if (isUnit(valuelessUnit) && valuelessUnit.value === null) {
+      // clone from valuelessUnit
+      this.fixPrefix = valuelessUnit.fixPrefix;
+      this.skipAutomaticSimplification = valuelessUnit.skipAutomaticSimplification;
+      this.dimensions = valuelessUnit.dimensions.slice(0);
+      this.units = valuelessUnit.units.map(u => _extends({}, u));
+    } else {
+      throw new TypeError('Second parameter in Unit constructor must be a string or valueless Unit');
+    }
+    this.value = this._normalize(value);
   }
+
   /**
    * Attach type information
    */
-
-
+  Object.defineProperty(Unit, 'name', {
+    value: 'Unit'
+  });
+  Unit.prototype.constructor = Unit;
   Unit.prototype.type = 'Unit';
-  Unit.prototype.isUnit = true; // private variables and functions for the Unit parser
+  Unit.prototype.isUnit = true;
 
+  // private variables and functions for the Unit parser
   var text, index, c;
-
   function skipWhitespace() {
     while (c === ' ' || c === '\t') {
       next();
     }
   }
-
   function isDigitDot(c) {
     return c >= '0' && c <= '9' || c === '.';
   }
-
   function isDigit(c) {
     return c >= '0' && c <= '9';
   }
-
   function next() {
     index++;
     c = text.charAt(index);
   }
-
   function revert(oldIndex) {
     index = oldIndex;
     c = text.charAt(index);
   }
-
   function parseNumber() {
     var number = '';
     var oldIndex = index;
-
     if (c === '+') {
       next();
     } else if (c === '-') {
       number += c;
       next();
     }
-
     if (!isDigitDot(c)) {
       // a + or - must be followed by a digit
       revert(oldIndex);
       return null;
-    } // get number, can have a single dot
-
+    }
 
+    // get number, can have a single dot
     if (c === '.') {
       number += c;
       next();
-
       if (!isDigit(c)) {
         // this is no legal number, it is just a dot
         revert(oldIndex);
@@ -160,68 +143,62 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
         number += c;
         next();
       }
-
       if (c === '.') {
         number += c;
         next();
       }
     }
-
     while (isDigit(c)) {
       number += c;
       next();
-    } // check for exponential notation like "2.3e-4" or "1.23e50"
-
+    }
 
+    // check for exponential notation like "2.3e-4" or "1.23e50"
     if (c === 'E' || c === 'e') {
       // The grammar branches here. This could either be part of an exponent or the start of a unit that begins with the letter e, such as "4exabytes"
+
       var tentativeNumber = '';
       var tentativeIndex = index;
       tentativeNumber += c;
       next();
-
       if (c === '+' || c === '-') {
         tentativeNumber += c;
         next();
-      } // Scientific notation MUST be followed by an exponent (otherwise we assume it is not scientific notation)
-
+      }
 
+      // Scientific notation MUST be followed by an exponent (otherwise we assume it is not scientific notation)
       if (!isDigit(c)) {
         // The e or E must belong to something else, so return the number without the e or E.
         revert(tentativeIndex);
         return number;
-      } // We can now safely say that this is scientific notation.
-
+      }
 
+      // We can now safely say that this is scientific notation.
       number = number + tentativeNumber;
-
       while (isDigit(c)) {
         number += c;
         next();
       }
     }
-
     return number;
   }
-
   function parseUnit() {
-    var unitName = ''; // Alphanumeric characters only; matches [a-zA-Z0-9]
+    var unitName = '';
 
+    // Alphanumeric characters only; matches [a-zA-Z0-9]
     while (isDigit(c) || Unit.isValidAlpha(c)) {
       unitName += c;
       next();
-    } // Must begin with [a-zA-Z]
-
+    }
 
+    // Must begin with [a-zA-Z]
     var firstC = unitName.charAt(0);
-
     if (Unit.isValidAlpha(firstC)) {
       return unitName;
     } else {
       return null;
     }
   }
-
   function parseCharacter(toFind) {
     if (c === toFind) {
       next();
@@ -230,6 +207,7 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
       return null;
     }
   }
+
   /**
    * Parse a string into a unit. The value of the unit is parsed as number,
    * BigNumber, or Fraction depending on the math.js config setting `number`.
@@ -240,24 +218,23 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
    * @param {string} str        A string like "5.2 inch", "4e2 cm/s^2"
    * @return {Unit} unit
    */
-
-
   Unit.parse = function (str, options) {
     options = options || {};
     text = str;
     index = -1;
     c = '';
-
     if (typeof text !== 'string') {
       throw new TypeError('Invalid argument in Unit.parse, string expected');
     }
-
     var unit = new Unit();
     unit.units = [];
     var powerMultiplierCurrent = 1;
-    var expectingUnit = false; // A unit should follow this pattern:
+    var expectingUnit = false;
+
+    // A unit should follow this pattern:
     // [number] ...[ [*/] unit[^number] ]
     // unit[^number] ... [ [*/] unit[^number] ]
+
     // Rules:
     // number is any floating point number.
     // unit is any alphanumeric string beginning with an alpha. Units with names like e3 should be avoided because they look like the exponent of a floating point number!
@@ -269,11 +246,11 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
     //   4erg
 
     next();
-    skipWhitespace(); // Optional number at the start of the string
+    skipWhitespace();
 
+    // Optional number at the start of the string
     var valueStr = parseNumber();
     var value = null;
-
     if (valueStr) {
       if (config.number === 'BigNumber') {
         value = new _BigNumber(valueStr);
@@ -288,10 +265,9 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
         // number
         value = parseFloat(valueStr);
       }
-
       skipWhitespace(); // Whitespace is not required here
-      // handle multiplication or division right after the value, like '1/s'
 
+      // handle multiplication or division right after the value, like '1/s'
       if (parseCharacter('*')) {
         powerMultiplierCurrent = 1;
         expectingUnit = true;
@@ -299,93 +275,83 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
         powerMultiplierCurrent = -1;
         expectingUnit = true;
       }
-    } // Stack to keep track of powerMultipliers applied to each parentheses group
-
+    }
 
-    var powerMultiplierStack = []; // Running product of all elements in powerMultiplierStack
+    // Stack to keep track of powerMultipliers applied to each parentheses group
+    var powerMultiplierStack = [];
 
+    // Running product of all elements in powerMultiplierStack
     var powerMultiplierStackProduct = 1;
-
     while (true) {
-      skipWhitespace(); // Check for and consume opening parentheses, pushing powerMultiplierCurrent to the stack
-      // A '(' will always appear directly before a unit.
+      skipWhitespace();
 
+      // Check for and consume opening parentheses, pushing powerMultiplierCurrent to the stack
+      // A '(' will always appear directly before a unit.
       while (c === '(') {
         powerMultiplierStack.push(powerMultiplierCurrent);
         powerMultiplierStackProduct *= powerMultiplierCurrent;
         powerMultiplierCurrent = 1;
         next();
         skipWhitespace();
-      } // Is there something here?
-
+      }
 
+      // Is there something here?
       var uStr = void 0;
-
       if (c) {
         var oldC = c;
         uStr = parseUnit();
-
         if (uStr === null) {
           throw new SyntaxError('Unexpected "' + oldC + '" in "' + text + '" at index ' + index.toString());
         }
       } else {
         // End of input.
         break;
-      } // Verify the unit exists and get the prefix (if any)
-
+      }
 
+      // Verify the unit exists and get the prefix (if any)
       var res = _findUnit(uStr);
-
       if (res === null) {
         // Unit not found.
         throw new SyntaxError('Unit "' + uStr + '" not found.');
       }
-
-      var power = powerMultiplierCurrent * powerMultiplierStackProduct; // Is there a "^ number"?
-
+      var power = powerMultiplierCurrent * powerMultiplierStackProduct;
+      // Is there a "^ number"?
       skipWhitespace();
-
       if (parseCharacter('^')) {
         skipWhitespace();
         var p = parseNumber();
-
         if (p === null) {
           // No valid number found for the power!
           throw new SyntaxError('In "' + str + '", "^" must be followed by a floating-point number');
         }
-
         power *= p;
-      } // Add the unit to the list
-
+      }
 
+      // Add the unit to the list
       unit.units.push({
         unit: res.unit,
         prefix: res.prefix,
-        power: power
+        power
       });
-
       for (var i = 0; i < BASE_DIMENSIONS.length; i++) {
         unit.dimensions[i] += (res.unit.dimensions[i] || 0) * power;
-      } // Check for and consume closing parentheses, popping from the stack.
-      // A ')' will always follow a unit.
-
+      }
 
+      // Check for and consume closing parentheses, popping from the stack.
+      // A ')' will always follow a unit.
       skipWhitespace();
-
       while (c === ')') {
         if (powerMultiplierStack.length === 0) {
           throw new SyntaxError('Unmatched ")" in "' + text + '" at index ' + index.toString());
         }
-
         powerMultiplierStackProduct /= powerMultiplierStack.pop();
         next();
         skipWhitespace();
-      } // "*" and "/" should mean we are expecting something to come next.
-      // Is there a forward slash? If so, negate powerMultiplierCurrent. The next unit or paren group is in the denominator.
-
+      }
 
+      // "*" and "/" should mean we are expecting something to come next.
+      // Is there a forward slash? If so, negate powerMultiplierCurrent. The next unit or paren group is in the denominator.
       expectingUnit = false;
-
       if (parseCharacter('*')) {
         // explicit multiplication
         powerMultiplierCurrent = 1;
@@ -397,9 +363,9 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
       } else {
         // implicit multiplication
         powerMultiplierCurrent = 1;
-      } // Replace the unit into the auto unit system
-
+      }
 
+      // Replace the unit into the auto unit system
       if (res.unit.base) {
         var baseDim = res.unit.base.key;
         UNIT_SYSTEMS.auto[baseDim] = {
@@ -407,40 +373,37 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
           prefix: res.prefix
         };
       }
-    } // Has the string been entirely consumed?
-
+    }
 
+    // Has the string been entirely consumed?
     skipWhitespace();
-
     if (c) {
       throw new SyntaxError('Could not parse: "' + str + '"');
-    } // Is there a trailing slash?
-
+    }
 
+    // Is there a trailing slash?
     if (expectingUnit) {
       throw new SyntaxError('Trailing characters: "' + str + '"');
-    } // Is the parentheses stack empty?
-
+    }
 
+    // Is the parentheses stack empty?
     if (powerMultiplierStack.length !== 0) {
       throw new SyntaxError('Unmatched "(" in "' + text + '"');
-    } // Are there any units at all?
-
+    }
 
+    // Are there any units at all?
     if (unit.units.length === 0 && !options.allowNoUnits) {
       throw new SyntaxError('"' + str + '" contains no units');
     }
-
     unit.value = value !== undefined ? unit._normalize(value) : null;
     return unit;
   };
+
   /**
    * create a copy of this unit
    * @memberof Unit
    * @return {Unit} Returns a cloned version of the unit
    */
-
-
   Unit.prototype.clone = function () {
     var unit = new Unit();
     unit.fixPrefix = this.fixPrefix;
@@ -448,33 +411,39 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
     unit.value = clone(this.value);
     unit.dimensions = this.dimensions.slice(0);
     unit.units = [];
-
     for (var i = 0; i < this.units.length; i++) {
       unit.units[i] = {};
-
       for (var p in this.units[i]) {
         if (hasOwnProperty(this.units[i], p)) {
           unit.units[i][p] = this.units[i][p];
         }
       }
     }
-
     return unit;
   };
+
+  /**
+   * Return the type of the value of this unit
+   *
+   * @memberof Unit
+   * @ return {string} type of the value of the unit
+   */
+  Unit.prototype.valueType = function () {
+    return typeOf(this.value);
+  };
+
   /**
    * Return whether the unit is derived (such as m/s, or cm^2, but not N)
    * @memberof Unit
    * @return {boolean} True if the unit is derived
    */
-
-
   Unit.prototype._isDerived = function () {
     if (this.units.length === 0) {
       return false;
     }
-
     return this.units.length > 1 || Math.abs(this.units[0].power - 1.0) > 1e-15;
   };
+
   /**
    * Normalize a value, based on its currently set unit(s)
    * @memberof Unit
@@ -482,38 +451,22 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
    * @return {number | BigNumber | Fraction | boolean} normalized value
    * @private
    */
-
-
   Unit.prototype._normalize = function (value) {
-    var unitValue, unitOffset, unitPower, unitPrefixValue;
-    var convert;
-
     if (value === null || value === undefined || this.units.length === 0) {
       return value;
-    } else if (this._isDerived()) {
-      // This is a derived unit, so do not apply offsets.
-      // For example, with J kg^-1 degC^-1 you would NOT want to apply the offset.
-      var res = value;
-      convert = Unit._getNumberConverter(typeOf(value)); // convert to Fraction or BigNumber if needed
-
-      for (var i = 0; i < this.units.length; i++) {
-        unitValue = convert(this.units[i].unit.value);
-        unitPrefixValue = convert(this.units[i].prefix.value);
-        unitPower = convert(this.units[i].power);
-        res = multiplyScalar(res, pow(multiplyScalar(unitValue, unitPrefixValue), unitPower));
-      }
-
-      return res;
-    } else {
-      // This is a single unit of power 1, like kg or degC
-      convert = Unit._getNumberConverter(typeOf(value)); // convert to Fraction or BigNumber if needed
+    }
+    var res = value;
+    var convert = Unit._getNumberConverter(typeOf(value)); // convert to Fraction or BigNumber if needed
 
-      unitValue = convert(this.units[0].unit.value);
-      unitOffset = convert(this.units[0].unit.offset);
-      unitPrefixValue = convert(this.units[0].prefix.value);
-      return multiplyScalar(addScalar(value, unitOffset), multiplyScalar(unitValue, unitPrefixValue));
+    for (var i = 0; i < this.units.length; i++) {
+      var unitValue = convert(this.units[i].unit.value);
+      var unitPrefixValue = convert(this.units[i].prefix.value);
+      var unitPower = convert(this.units[i].power);
+      res = multiplyScalar(res, pow(multiplyScalar(unitValue, unitPrefixValue), unitPower));
     }
+    return res;
   };
+
   /**
    * Denormalize a value, based on its currently set unit(s)
    * @memberof Unit
@@ -522,44 +475,22 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
    * @return {number} denormalized value
    * @private
    */
-
-
   Unit.prototype._denormalize = function (value, prefixValue) {
-    var unitValue, unitOffset, unitPower, unitPrefixValue;
-    var convert;
-
     if (value === null || value === undefined || this.units.length === 0) {
       return value;
-    } else if (this._isDerived()) {
-      // This is a derived unit, so do not apply offsets.
-      // For example, with J kg^-1 degC^-1 you would NOT want to apply the offset.
-      // Also, prefixValue is ignored--but we will still use the prefix value stored in each unit, since kg is usually preferable to g unless the user decides otherwise.
-      var res = value;
-      convert = Unit._getNumberConverter(typeOf(value)); // convert to Fraction or BigNumber if needed
-
-      for (var i = 0; i < this.units.length; i++) {
-        unitValue = convert(this.units[i].unit.value);
-        unitPrefixValue = convert(this.units[i].prefix.value);
-        unitPower = convert(this.units[i].power);
-        res = divideScalar(res, pow(multiplyScalar(unitValue, unitPrefixValue), unitPower));
-      }
-
-      return res;
-    } else {
-      // This is a single unit of power 1, like kg or degC
-      convert = Unit._getNumberConverter(typeOf(value)); // convert to Fraction or BigNumber if needed
-
-      unitValue = convert(this.units[0].unit.value);
-      unitPrefixValue = convert(this.units[0].prefix.value);
-      unitOffset = convert(this.units[0].unit.offset);
+    }
+    var res = value;
+    var convert = Unit._getNumberConverter(typeOf(value)); // convert to Fraction or BigNumber if needed
 
-      if (prefixValue === undefined || prefixValue === null) {
-        return subtract(divideScalar(divideScalar(value, unitValue), unitPrefixValue), unitOffset);
-      } else {
-        return subtract(divideScalar(divideScalar(value, unitValue), prefixValue), unitOffset);
-      }
+    for (var i = 0; i < this.units.length; i++) {
+      var unitValue = convert(this.units[i].unit.value);
+      var unitPrefixValue = convert(this.units[i].prefix.value);
+      var unitPower = convert(this.units[i].power);
+      res = divideScalar(res, pow(multiplyScalar(unitValue, unitPrefixValue), unitPower));
     }
+    return res;
   };
+
   /**
    * Find a unit from a string
    * @memberof Unit
@@ -568,9 +499,7 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
    *                                  prefix is returned. Else, null is returned.
    * @private
    */
-
-
-  function _findUnit(str) {
+  var _findUnit = memoize(str => {
     // First, match units names exactly. For example, a user could define 'mm' as 10^-4 m, which is silly, but then we would want 'mm' to match the user-defined unit.
     if (hasOwnProperty(UNITS, str)) {
       var unit = UNITS[str];
@@ -580,16 +509,13 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
         prefix
       };
     }
-
     for (var _name in UNITS) {
       if (hasOwnProperty(UNITS, _name)) {
         if (endsWith(str, _name)) {
           var _unit = UNITS[_name];
           var prefixLen = str.length - _name.length;
           var prefixName = str.substring(0, prefixLen);
-
           var _prefix = hasOwnProperty(_unit.prefixes, prefixName) ? _unit.prefixes[prefixName] : undefined;
-
           if (_prefix !== undefined) {
             // store unit, prefix, and value
             return {
@@ -600,9 +526,12 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
         }
       }
     }
-
     return null;
-  }
+  }, {
+    hasher: args => args[0],
+    limit: 100
+  });
+
   /**
    * Test if the given expression is a unit.
    * The unit can have a prefix but cannot have a value.
@@ -611,37 +540,33 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
    *                        The unit can have prefix, like "cm"
    * @return {boolean}      true if the given string is a unit
    */
-
-
   Unit.isValuelessUnit = function (name) {
     return _findUnit(name) !== null;
   };
+
   /**
    * check if this unit has given base unit
    * If this unit is a derived unit, this will ALWAYS return false, since by definition base units are not derived.
    * @memberof Unit
    * @param {BASE_UNITS | string | undefined} base
    */
-
-
   Unit.prototype.hasBase = function (base) {
     if (typeof base === 'string') {
       base = BASE_UNITS[base];
     }
-
     if (!base) {
       return false;
-    } // All dimensions must be the same
-
+    }
 
+    // All dimensions must be the same
     for (var i = 0; i < BASE_DIMENSIONS.length; i++) {
       if (Math.abs((this.dimensions[i] || 0) - (base.dimensions[i] || 0)) > 1e-12) {
         return false;
       }
     }
-
     return true;
   };
+
   /**
    * Check if this unit has a base or bases equal to another base or bases
    * For derived units, the exponent on each base also must match
@@ -649,8 +574,6 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
    * @param {Unit} other
    * @return {boolean} true if equal base
    */
-
-
   Unit.prototype.equalBase = function (other) {
     // All dimensions must be the same
     for (var i = 0; i < BASE_DIMENSIONS.length; i++) {
@@ -658,45 +581,41 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
         return false;
       }
     }
-
     return true;
   };
+
   /**
    * Check if this unit equals another unit
    * @memberof Unit
    * @param {Unit} other
    * @return {boolean} true if both units are equal
    */
-
-
   Unit.prototype.equals = function (other) {
     return this.equalBase(other) && equal(this.value, other.value);
   };
+
   /**
-   * Multiply this unit with another one
+   * Multiply this unit with another one or with a scalar
    * @memberof Unit
    * @param {Unit} other
    * @return {Unit} product of this unit and the other unit
    */
-
-
-  Unit.prototype.multiply = function (other) {
+  Unit.prototype.multiply = function (_other) {
     var res = this.clone();
-
+    var other = isUnit(_other) ? _other : new Unit(_other);
     for (var i = 0; i < BASE_DIMENSIONS.length; i++) {
       // Dimensions arrays may be of different lengths. Default to 0.
       res.dimensions[i] = (this.dimensions[i] || 0) + (other.dimensions[i] || 0);
-    } // Append other's units list onto res
-
+    }
 
+    // Append other's units list onto res
     for (var _i = 0; _i < other.units.length; _i++) {
       // Make a shallow copy of every unit
       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
-
+    }
 
+    // If at least one operand has a value, then the result should also have a value
     if (this.value !== null || other.value !== null) {
       var valThis = this.value === null ? this._normalize(1) : this.value;
       var valOther = other.value === null ? other._normalize(1) : other.value;
@@ -704,37 +623,47 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
     } else {
       res.value = null;
     }
-
-    res.skipAutomaticSimplification = false;
+    if (isUnit(_other)) {
+      res.skipAutomaticSimplification = false;
+    }
     return getNumericIfUnitless(res);
   };
+
+  /**
+   * Divide a number by this unit
+   *
+   * @memberof Unit
+   * @param {numeric} numerator
+   * @param {unit} result of dividing numerator by this unit
+   */
+  Unit.prototype.divideInto = function (numerator) {
+    return new Unit(numerator).divide(this);
+  };
+
   /**
    * Divide this unit by another one
    * @memberof Unit
-   * @param {Unit} other
+   * @param {Unit | numeric} other
    * @return {Unit} result of dividing this unit by the other unit
    */
-
-
-  Unit.prototype.divide = function (other) {
+  Unit.prototype.divide = function (_other) {
     var res = this.clone();
-
+    var other = isUnit(_other) ? _other : new Unit(_other);
     for (var i = 0; i < BASE_DIMENSIONS.length; i++) {
       // Dimensions arrays may be of different lengths. Default to 0.
       res.dimensions[i] = (this.dimensions[i] || 0) - (other.dimensions[i] || 0);
-    } // Invert and append other's units list onto res
-
+    }
 
+    // Invert and append other's units list onto res
     for (var _i2 = 0; _i2 < other.units.length; _i2++) {
       // Make a shallow copy of every unit
       var inverted = _objectSpread(_objectSpread({}, other.units[_i2]), {}, {
         power: -other.units[_i2].power
       });
-
       res.units.push(inverted);
-    } // If at least one operand has a value, the result should have a value
-
+    }
 
+    // If at least one operand has a value, the result should have a value
     if (this.value !== null || other.value !== null) {
       var valThis = this.value === null ? this._normalize(1) : this.value;
       var valOther = other.value === null ? other._normalize(1) : other.value;
@@ -742,33 +671,33 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
     } else {
       res.value = null;
     }
-
-    res.skipAutomaticSimplification = false;
+    if (isUnit(_other)) {
+      res.skipAutomaticSimplification = false;
+    }
     return getNumericIfUnitless(res);
   };
+
   /**
    * Calculate the power of a unit
    * @memberof Unit
    * @param {number | Fraction | BigNumber} p
    * @returns {Unit}      The result: this^p
    */
-
-
   Unit.prototype.pow = function (p) {
     var res = this.clone();
-
     for (var i = 0; i < BASE_DIMENSIONS.length; i++) {
       // Dimensions arrays may be of different lengths. Default to 0.
       res.dimensions[i] = (this.dimensions[i] || 0) * p;
-    } // Adjust the power of each unit in the list
-
+    }
 
+    // Adjust the power of each unit in the list
     for (var _i3 = 0; _i3 < res.units.length; _i3++) {
       res.units[_i3].power *= p;
     }
-
     if (res.value !== null) {
-      res.value = pow(res.value, p); // only allow numeric output, we don't want to return a Complex number
+      res.value = pow(res.value, p);
+
+      // only allow numeric output, we don't want to return a Complex number
       // if (!isNumeric(res.value)) {
       //  res.value = NaN
       // }
@@ -776,17 +705,15 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
     } else {
       res.value = null;
     }
-
     res.skipAutomaticSimplification = false;
     return getNumericIfUnitless(res);
   };
+
   /**
    * Return the numeric value of this unit if it is dimensionless, has a value, and config.predictable == false; or the original unit otherwise
    * @param {Unit} unit
    * @returns {number | Fraction | BigNumber | Unit}  The numeric value of the unit if conditions are met, or the original unit otherwise
    */
-
-
   function getNumericIfUnitless(unit) {
     if (unit.equalBase(BASE_UNITS.NONE) && unit.value !== null && !config.predictable) {
       return unit.value;
@@ -794,74 +721,78 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
       return unit;
     }
   }
+
   /**
    * Calculate the absolute value of a unit
    * @memberof Unit
    * @param {number | Fraction | BigNumber} x
    * @returns {Unit}      The result: |x|, absolute value of x
    */
-
-
   Unit.prototype.abs = function () {
-    // This gives correct, but unexpected, results for units with an offset.
-    // For example, abs(-283.15 degC) = -263.15 degC !!!
     var ret = this.clone();
-    ret.value = ret.value !== null ? abs(ret.value) : null;
-
+    if (ret.value !== null) {
+      if (ret._isDerived() || ret.units[0].unit.offset === 0) {
+        ret.value = abs(ret.value);
+      } else {
+        // To give the correct, but unexpected, results for units with an offset.
+        // For example, abs(-283.15 degC) = -263.15 degC !!!
+        // We must take the offset into consideration here
+        var convert = ret._numberConverter(); // convert to Fraction or BigNumber if needed
+        var unitValue = convert(ret.units[0].unit.value);
+        var nominalOffset = convert(ret.units[0].unit.offset);
+        var unitOffset = multiplyScalar(unitValue, nominalOffset);
+        ret.value = subtractScalar(abs(addScalar(ret.value, unitOffset)), unitOffset);
+      }
+    }
     for (var i in ret.units) {
       if (ret.units[i].unit.name === 'VA' || ret.units[i].unit.name === 'VAR') {
         ret.units[i].unit = UNITS.W;
       }
     }
-
     return ret;
   };
+
   /**
    * Convert the unit to a specific unit name.
    * @memberof Unit
    * @param {string | Unit} valuelessUnit   A unit without value. Can have prefix, like "cm"
    * @returns {Unit} Returns a clone of the unit with a fixed prefix and unit.
    */
-
-
   Unit.prototype.to = function (valuelessUnit) {
-    var other;
     var value = this.value === null ? this._normalize(1) : this.value;
-
+    var other;
     if (typeof valuelessUnit === 'string') {
-      // other = new Unit(null, valuelessUnit)
       other = Unit.parse(valuelessUnit);
-
-      if (!this.equalBase(other)) {
-        throw new Error("Units do not match ('".concat(other.toString(), "' != '").concat(this.toString(), "')"));
-      }
-
-      if (other.value !== null) {
-        throw new Error('Cannot convert to a unit with a value');
-      }
-
-      other.value = clone(value);
-      other.fixPrefix = true;
-      other.skipAutomaticSimplification = true;
-      return other;
     } else if (isUnit(valuelessUnit)) {
-      if (!this.equalBase(valuelessUnit)) {
-        throw new Error("Units do not match ('".concat(valuelessUnit.toString(), "' != '").concat(this.toString(), "')"));
-      }
-
-      if (valuelessUnit.value !== null) {
-        throw new Error('Cannot convert to a unit with a value');
-      }
-
       other = valuelessUnit.clone();
-      other.value = clone(value);
-      other.fixPrefix = true;
-      other.skipAutomaticSimplification = true;
-      return other;
     } else {
       throw new Error('String or Unit expected as parameter');
     }
+    if (!this.equalBase(other)) {
+      throw new Error("Units do not match ('".concat(other.toString(), "' != '").concat(this.toString(), "')"));
+    }
+    if (other.value !== null) {
+      throw new Error('Cannot convert to a unit with a value');
+    }
+    if (this.value === null || this._isDerived() || this.units[0].unit.offset === other.units[0].unit.offset) {
+      other.value = clone(value);
+    } else {
+      /* Need to adjust value by difference in offset to convert */
+      var convert = Unit._getNumberConverter(typeOf(value)); // convert to Fraction or BigNumber if needed
+
+      var thisUnitValue = this.units[0].unit.value;
+      var thisNominalOffset = this.units[0].unit.offset;
+      var thisUnitOffset = multiplyScalar(thisUnitValue, thisNominalOffset);
+      var otherUnitValue = other.units[0].unit.value;
+      var otherNominalOffset = other.units[0].unit.offset;
+      var otherUnitOffset = multiplyScalar(otherUnitValue, otherNominalOffset);
+      other.value = addScalar(value, convert(subtractScalar(thisUnitOffset, otherUnitOffset)));
+    }
+    other.fixPrefix = true;
+    other.skipAutomaticSimplification = true;
+    return other;
   };
+
   /**
    * Return the value of the unit when represented with given valueless unit
    * @memberof Unit
@@ -869,53 +800,46 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
    * @return {number} Returns the unit value as number.
    */
   // TODO: deprecate Unit.toNumber? It's always better to use toNumeric
-
-
   Unit.prototype.toNumber = function (valuelessUnit) {
     return toNumber(this.toNumeric(valuelessUnit));
   };
+
   /**
    * Return the value of the unit in the original numeric type
    * @memberof Unit
    * @param {string | Unit} valuelessUnit    For example 'cm' or 'inch'
    * @return {number | BigNumber | Fraction} Returns the unit value
    */
-
-
   Unit.prototype.toNumeric = function (valuelessUnit) {
     var other;
-
     if (valuelessUnit) {
       // Allow getting the numeric value without converting to a different unit
       other = this.to(valuelessUnit);
     } else {
       other = this.clone();
     }
-
     if (other._isDerived() || other.units.length === 0) {
       return other._denormalize(other.value);
     } else {
       return other._denormalize(other.value, other.units[0].prefix.value);
     }
   };
+
   /**
    * Get a string representation of the unit.
    * @memberof Unit
    * @return {string}
    */
-
-
   Unit.prototype.toString = function () {
     return this.format();
   };
+
   /**
    * Get a JSON representation of the unit
    * @memberof Unit
    * @returns {Object} Returns a JSON object structured as:
    *                   `{"mathjs": "Unit", "value": 2, "unit": "cm", "fixPrefix": false}`
    */
-
-
   Unit.prototype.toJSON = function () {
     return {
       mathjs: 'Unit',
@@ -924,6 +848,7 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
       fixPrefix: this.fixPrefix
     };
   };
+
   /**
    * Instantiate a Unit from a JSON object
    * @memberof Unit
@@ -931,32 +856,29 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
    *                       `{"mathjs": "Unit", "value": 2, "unit": "cm", "fixPrefix": false}`
    * @return {Unit}
    */
-
-
   Unit.fromJSON = function (json) {
     var unit = new Unit(json.value, json.unit);
     unit.fixPrefix = json.fixPrefix || false;
     return unit;
   };
+
   /**
    * Returns the string representation of the unit.
    * @memberof Unit
    * @return {string}
    */
-
-
   Unit.prototype.valueOf = Unit.prototype.toString;
+
   /**
    * Simplify this Unit's unit list and return a new Unit with the simplified list.
    * The returned Unit will contain a list of the "best" units for formatting.
    */
-
   Unit.prototype.simplify = function () {
     var ret = this.clone();
-    var proposedUnitList = []; // Search for a matching base
+    var proposedUnitList = [];
 
+    // Search for a matching base
     var matchingBase;
-
     for (var key in currentUnitSystem) {
       if (hasOwnProperty(currentUnitSystem, key)) {
         if (ret.hasBase(BASE_UNITS[key])) {
@@ -965,19 +887,16 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
         }
       }
     }
-
     if (matchingBase === 'NONE') {
       ret.units = [];
     } else {
       var matchingUnit;
-
       if (matchingBase) {
         // Does the unit system have a matching unit?
         if (hasOwnProperty(currentUnitSystem, matchingBase)) {
           matchingUnit = currentUnitSystem[matchingBase];
         }
       }
-
       if (matchingUnit) {
         ret.units = [{
           unit: matchingUnit.unit,
@@ -989,10 +908,8 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
         // 5 (kg m^2) / (s^3 mol)
         // Build an representation from the base units of the current unit system
         var missingBaseDim = false;
-
         for (var i = 0; i < BASE_DIMENSIONS.length; i++) {
           var baseDim = BASE_DIMENSIONS[i];
-
           if (Math.abs(ret.dimensions[i] || 0) > 1e-12) {
             if (hasOwnProperty(currentUnitSystem, baseDim)) {
               proposedUnitList.push({
@@ -1004,32 +921,30 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
               missingBaseDim = true;
             }
           }
-        } // Is the proposed unit list "simpler" than the existing one?
-
+        }
 
+        // Is the proposed unit list "simpler" than the existing one?
         if (proposedUnitList.length < ret.units.length && !missingBaseDim) {
           // Replace this unit list with the proposed list
           ret.units = proposedUnitList;
         }
       }
     }
-
     return ret;
   };
+
   /**
    * Returns a new Unit in the SI system with the same value as this one
    */
-
-
   Unit.prototype.toSI = function () {
     var ret = this.clone();
-    var proposedUnitList = []; // Multiple units or units with powers are formatted like this:
+    var proposedUnitList = [];
+
+    // Multiple units or units with powers are formatted like this:
     // 5 (kg m^2) / (s^3 mol)
     // Build an representation from the base units of the SI unit system
-
     for (var i = 0; i < BASE_DIMENSIONS.length; i++) {
       var baseDim = BASE_DIMENSIONS[i];
-
       if (Math.abs(ret.dimensions[i] || 0) > 1e-12) {
         if (hasOwnProperty(UNIT_SYSTEMS.si, baseDim)) {
           proposedUnitList.push({
@@ -1041,32 +956,29 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
           throw new Error('Cannot express custom unit ' + baseDim + ' in SI units');
         }
       }
-    } // Replace this unit list with the proposed list
-
+    }
 
+    // Replace this unit list with the proposed list
     ret.units = proposedUnitList;
     ret.fixPrefix = true;
     ret.skipAutomaticSimplification = true;
     return ret;
   };
+
   /**
    * Get a string representation of the units of this Unit, without the value. The unit list is formatted as-is without first being simplified.
    * @memberof Unit
    * @return {string}
    */
-
-
   Unit.prototype.formatUnits = function () {
     var strNum = '';
     var strDen = '';
     var nNum = 0;
     var nDen = 0;
-
     for (var i = 0; i < this.units.length; i++) {
       if (this.units[i].power > 0) {
         nNum++;
         strNum += ' ' + this.units[i].prefix.name + this.units[i].unit.name;
-
         if (Math.abs(this.units[i].power - 1.0) > 1e-15) {
           strNum += '^' + this.units[i].power;
         }
@@ -1074,13 +986,11 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
         nDen++;
       }
     }
-
     if (nDen > 0) {
       for (var _i4 = 0; _i4 < this.units.length; _i4++) {
         if (this.units[_i4].power < 0) {
           if (nNum > 0) {
             strDen += ' ' + this.units[_i4].prefix.name + this.units[_i4].unit.name;
-
             if (Math.abs(this.units[_i4].power + 1.0) > 1e-15) {
               strDen += '^' + -this.units[_i4].power;
             }
@@ -1090,29 +1000,26 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
           }
         }
       }
-    } // Remove leading " "
-
-
+    }
+    // Remove leading " "
     strNum = strNum.substr(1);
-    strDen = strDen.substr(1); // Add parans for better copy/paste back into evaluate, for example, or for better pretty print formatting
+    strDen = strDen.substr(1);
 
+    // Add parans for better copy/paste back into evaluate, for example, or for better pretty print formatting
     if (nNum > 1 && nDen > 0) {
       strNum = '(' + strNum + ')';
     }
-
     if (nDen > 1 && nNum > 0) {
       strDen = '(' + strDen + ')';
     }
-
     var str = strNum;
-
     if (nNum > 0 && nDen > 0) {
       str += ' / ';
     }
-
     str += strDen;
     return str;
   };
+
   /**
    * Get a string representation of the Unit, with optional formatting options.
    * @memberof Unit
@@ -1122,20 +1029,17 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
    *                                                options.
    * @return {string}
    */
-
-
   Unit.prototype.format = function (options) {
     // Simplfy the unit list, unless it is valueless or was created directly in the
     // constructor or as the result of to or toSI
-    var simp = this.skipAutomaticSimplification || this.value === null ? this.clone() : this.simplify(); // Apply some custom logic for handling VA and VAR. The goal is to express the value of the unit as a real value, if possible. Otherwise, use a real-valued unit instead of a complex-valued one.
+    var simp = this.skipAutomaticSimplification || this.value === null ? this.clone() : this.simplify();
 
+    // Apply some custom logic for handling VA and VAR. The goal is to express the value of the unit as a real value, if possible. Otherwise, use a real-valued unit instead of a complex-valued one.
     var isImaginary = false;
-
     if (typeof simp.value !== 'undefined' && simp.value !== null && isComplex(simp.value)) {
       // TODO: Make this better, for example, use relative magnitude of re and im rather than absolute
       isImaginary = Math.abs(simp.value.re) < 1e-14;
     }
-
     for (var i in simp.units) {
       if (hasOwnProperty(simp.units, i)) {
         if (simp.units[i].unit) {
@@ -1146,10 +1050,10 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
           }
         }
       }
-    } // Now apply the best prefix
-    // Units must have only one unit and not have the fixPrefix flag set
-
+    }
 
+    // Now apply the best prefix
+    // Units must have only one unit and not have the fixPrefix flag set
     if (simp.units.length === 1 && !simp.fixPrefix) {
       // Units must have integer powers, otherwise the prefix will change the
       // outputted value by not-an-integer-power-of-ten
@@ -1158,69 +1062,57 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
         simp.units[0].prefix = simp._bestPrefix();
       }
     }
-
     var value = simp._denormalize(simp.value);
-
     var str = simp.value !== null ? format(value, options || {}) : '';
     var unitStr = simp.formatUnits();
-
     if (simp.value && isComplex(simp.value)) {
       str = '(' + str + ')'; // Surround complex values with ( ) to enable better parsing
     }
-
     if (unitStr.length > 0 && str.length > 0) {
       str += ' ';
     }
-
     str += unitStr;
     return str;
   };
+
   /**
    * Calculate the best prefix using current value.
    * @memberof Unit
    * @returns {Object} prefix
    * @private
    */
-
-
   Unit.prototype._bestPrefix = function () {
     if (this.units.length !== 1) {
       throw new Error('Can only compute the best prefix for single units with integer powers, like kg, s^2, N^-1, and so forth!');
     }
-
     if (Math.abs(this.units[0].power - Math.round(this.units[0].power)) >= 1e-14) {
       throw new Error('Can only compute the best prefix for single units with integer powers, like kg, s^2, N^-1, and so forth!');
-    } // find the best prefix value (resulting in the value of which
+    }
+
+    // find the best prefix value (resulting in the value of which
     // the absolute value of the log10 is closest to zero,
     // though with a little offset of 1.2 for nicer values: you get a
     // sequence 1mm 100mm 500mm 0.6m 1m 10m 100m 500m 0.6km 1km ...
+
     // Note: the units value can be any numeric type, but to find the best
     // prefix it's enough to work with limited precision of a regular number
     // Update: using mathjs abs since we also allow complex numbers
-
-
     var absValue = this.value !== null ? abs(this.value) : 0;
     var absUnitValue = abs(this.units[0].unit.value);
     var bestPrefix = this.units[0].prefix;
-
     if (absValue === 0) {
       return bestPrefix;
     }
-
     var power = this.units[0].power;
     var bestDiff = Math.log(absValue / Math.pow(bestPrefix.value * absUnitValue, power)) / Math.LN10 - 1.2;
     if (bestDiff > -2.200001 && bestDiff < 1.800001) return bestPrefix; // Allow the original prefix
-
     bestDiff = Math.abs(bestDiff);
     var prefixes = this.units[0].unit.prefixes;
-
     for (var p in prefixes) {
       if (hasOwnProperty(prefixes, p)) {
         var prefix = prefixes[p];
-
         if (prefix.scientific) {
           var diff = Math.abs(Math.log(absValue / Math.pow(prefix.value * absUnitValue, power)) / Math.LN10 - 1.2);
-
           if (diff < bestDiff || diff === bestDiff && prefix.name.length < bestPrefix.name.length) {
             // choose the prefix with the smallest diff, or if equal, choose the one
             // with the shortest name (can happen with SHORTLONG for example)
@@ -1230,9 +1122,9 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
         }
       }
     }
-
     return bestPrefix;
   };
+
   /**
    * Returns an array of units whose sum is equal to this unit
    * @memberof Unit
@@ -1246,53 +1138,46 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
    *
    * @return {Array} An array of units.
    */
-
-
   Unit.prototype.splitUnit = function (parts) {
     var x = this.clone();
     var ret = [];
-
     for (var i = 0; i < parts.length; i++) {
       // Convert x to the requested unit
       x = x.to(parts[i]);
-      if (i === parts.length - 1) break; // Get the numeric value of this unit
+      if (i === parts.length - 1) break;
 
-      var xNumeric = x.toNumeric(); // Check to see if xNumeric is nearly equal to an integer,
-      // since fix can incorrectly round down if there is round-off error
+      // Get the numeric value of this unit
+      var xNumeric = x.toNumeric();
 
+      // Check to see if xNumeric is nearly equal to an integer,
+      // since fix can incorrectly round down if there is round-off error
       var xRounded = round(xNumeric);
       var xFixed = void 0;
       var isNearlyEqual = equal(xRounded, xNumeric);
-
       if (isNearlyEqual) {
         xFixed = xRounded;
       } else {
         xFixed = fix(x.toNumeric());
       }
-
       var y = new Unit(xFixed, parts[i].toString());
       ret.push(y);
-      x = subtract(x, y);
-    } // This little bit fixes a bug where the remainder should be 0 but is a little bit off.
+      x = subtractScalar(x, y);
+    }
+
+    // This little bit fixes a bug where the remainder should be 0 but is a little bit off.
     // But instead of comparing x, the remainder, with zero--we will compare the sum of
     // all the parts so far with the original value. If they are nearly equal,
     // we set the remainder to 0.
-
-
     var testSum = 0;
-
     for (var _i5 = 0; _i5 < ret.length; _i5++) {
       testSum = addScalar(testSum, ret[_i5].value);
     }
-
     if (equal(testSum, this.value)) {
       x.value = 0;
     }
-
     ret.push(x);
     return ret;
   };
-
   var PREFIXES = {
     NONE: {
       '': {
@@ -1933,6 +1818,7 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
   PREFIXES.SHORTLONG = _extends({}, PREFIXES.SHORT, PREFIXES.LONG);
   PREFIXES.BINARY_SHORT = _extends({}, PREFIXES.BINARY_SHORT_SI, PREFIXES.BINARY_SHORT_IEC);
   PREFIXES.BINARY_LONG = _extends({}, PREFIXES.BINARY_LONG_SI, PREFIXES.BINARY_LONG_IEC);
+
   /* Internally, each unit is represented by a value and a dimension array. The elements of the dimensions array have the following meaning:
    * Index  Dimension
    * -----  ---------
@@ -2027,13 +1913,11 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
       dimensions: [0, 0, 0, 0, 0, 0, 0, 0, 1]
     }
   };
-
   for (var key in BASE_UNITS) {
     if (hasOwnProperty(BASE_UNITS, key)) {
       BASE_UNITS[key].key = key;
     }
   }
-
   var BASE_UNIT_NONE = {};
   var UNIT_NONE = {
     name: '',
@@ -2171,6 +2055,7 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
       offset: 0
     },
     // 1/1000 inch
+
     // Surface
     m2: {
       name: 'm2',
@@ -2251,6 +2136,7 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
       offset: 0
     },
     // 10000 m2
+
     // Volume
     m3: {
       name: 'm3',
@@ -2339,6 +2225,7 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
       offset: 0
     },
     // 0.05 mL = 5e-8 m3
+
     // Liquid volume
     minim: {
       name: 'minim',
@@ -2436,6 +2323,7 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
       offset: 0
     },
     // 238.4810 L
+
     // {name: 'min', base: BASE_UNITS.VOLUME, prefixes: PREFIXES.NONE, value: 0.00000006161152, offset: 0}, // 0.06161152 mL // min is already in use as minute
     fldr: {
       name: 'fldr',
@@ -2510,6 +2398,7 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
     },
     // 158.9873 L
     // {name: 'hogshead', base: BASE_UNITS.VOLUME, prefixes: PREFIXES.NONE, value: 0.2384810, offset: 0}, // 238.4810 L // TODO: hh?
+
     // Mass
     g: {
       name: 'g',
@@ -2844,62 +2733,62 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
     },
     // Temperature
     // K(C) = °C + 273.15
-    // K(F) = (°F + 459.67) / 1.8
-    // K(R) = °R / 1.8
+    // K(F) = (°F + 459.67) * (5 / 9)
+    // K(R) = °R * (5 / 9)
     K: {
       name: 'K',
       base: BASE_UNITS.TEMPERATURE,
-      prefixes: PREFIXES.NONE,
+      prefixes: PREFIXES.SHORT,
       value: 1,
       offset: 0
     },
     degC: {
       name: 'degC',
       base: BASE_UNITS.TEMPERATURE,
-      prefixes: PREFIXES.NONE,
+      prefixes: PREFIXES.SHORT,
       value: 1,
       offset: 273.15
     },
     degF: {
       name: 'degF',
       base: BASE_UNITS.TEMPERATURE,
-      prefixes: PREFIXES.NONE,
-      value: 1 / 1.8,
+      prefixes: PREFIXES.SHORT,
+      value: new _Fraction(5, 9),
       offset: 459.67
     },
     degR: {
       name: 'degR',
       base: BASE_UNITS.TEMPERATURE,
-      prefixes: PREFIXES.NONE,
-      value: 1 / 1.8,
+      prefixes: PREFIXES.SHORT,
+      value: new _Fraction(5, 9),
       offset: 0
     },
     kelvin: {
       name: 'kelvin',
       base: BASE_UNITS.TEMPERATURE,
-      prefixes: PREFIXES.NONE,
+      prefixes: PREFIXES.LONG,
       value: 1,
       offset: 0
     },
     celsius: {
       name: 'celsius',
       base: BASE_UNITS.TEMPERATURE,
-      prefixes: PREFIXES.NONE,
+      prefixes: PREFIXES.LONG,
       value: 1,
       offset: 273.15
     },
     fahrenheit: {
       name: 'fahrenheit',
       base: BASE_UNITS.TEMPERATURE,
-      prefixes: PREFIXES.NONE,
-      value: 1 / 1.8,
+      prefixes: PREFIXES.LONG,
+      value: new _Fraction(5, 9),
       offset: 459.67
     },
     rankine: {
       name: 'rankine',
       base: BASE_UNITS.TEMPERATURE,
-      prefixes: PREFIXES.NONE,
-      value: 1 / 1.8,
+      prefixes: PREFIXES.LONG,
+      value: new _Fraction(5, 9),
       offset: 0
     },
     // amount of substance
@@ -2935,6 +2824,7 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
     // TODO: units STERADIAN
     // {name: 'sr', base: BASE_UNITS.STERADIAN, prefixes: PREFIXES.NONE, value: 1, offset: 0},
     // {name: 'steradian', base: BASE_UNITS.STERADIAN, prefixes: PREFIXES.NONE, value: 1, offset: 0},
+
     // Force
     N: {
       name: 'N',
@@ -3003,14 +2893,15 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
     joule: {
       name: 'joule',
       base: BASE_UNITS.ENERGY,
-      prefixes: PREFIXES.SHORT,
+      prefixes: PREFIXES.LONG,
       value: 1,
       offset: 0
     },
     erg: {
       name: 'erg',
       base: BASE_UNITS.ENERGY,
-      prefixes: PREFIXES.NONE,
+      prefixes: PREFIXES.SHORTLONG,
+      // Both kiloerg and kerg are acceptable
       value: 1e-7,
       offset: 0
     },
@@ -3190,7 +3081,6 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
       value: 1,
       offset: 0
     },
-
     /*
      * Unicode breaks in browsers if charset is not specified
     Ω: {
@@ -3290,8 +3180,9 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
       value: 8,
       offset: 0
     }
-  }; // aliases (formerly plurals)
+  };
 
+  // aliases (formerly plurals)
   var ALIASES = {
     meters: 'meter',
     inches: 'inch',
@@ -3369,6 +3260,8 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
     watts: 'watt',
     joules: 'joule',
     amperes: 'ampere',
+    amps: 'ampere',
+    amp: 'ampere',
     coulombs: 'coulomb',
     volts: 'volt',
     ohms: 'ohm',
@@ -3380,48 +3273,39 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
     bit: 'bits',
     byte: 'bytes'
   };
+
   /**
    * Calculate the values for the angle units.
    * Value is calculated as number or BigNumber depending on the configuration
    * @param {{number: 'number' | 'BigNumber'}} config
    */
-
   function calculateAngleValues(config) {
     if (config.number === 'BigNumber') {
       var pi = createPi(_BigNumber);
       UNITS.rad.value = new _BigNumber(1);
       UNITS.deg.value = pi.div(180); // 2 * pi / 360
-
       UNITS.grad.value = pi.div(200); // 2 * pi / 400
-
       UNITS.cycle.value = pi.times(2); // 2 * pi
-
       UNITS.arcsec.value = pi.div(648000); // 2 * pi / 360 / 3600
-
       UNITS.arcmin.value = pi.div(10800); // 2 * pi / 360 / 60
     } else {
       // number
       UNITS.rad.value = 1;
       UNITS.deg.value = Math.PI / 180; // 2 * pi / 360
-
       UNITS.grad.value = Math.PI / 200; // 2 * pi / 400
-
       UNITS.cycle.value = Math.PI * 2; // 2 * pi
-
       UNITS.arcsec.value = Math.PI / 648000; // 2 * pi / 360 / 3600
-
       UNITS.arcmin.value = Math.PI / 10800; // 2 * pi / 360 / 60
-    } // copy to the full names of the angles
-
+    }
 
+    // copy to the full names of the angles
     UNITS.radian.value = UNITS.rad.value;
     UNITS.degree.value = UNITS.deg.value;
     UNITS.gradian.value = UNITS.grad.value;
-  } // apply the angle values now
-
+  }
 
+  // apply the angle values now
   calculateAngleValues(config);
-
   if (on) {
     // recalculate the values on change of configuration
     on('config', function (curr, prev) {
@@ -3430,13 +3314,12 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
       }
     });
   }
+
   /**
    * A unit system is a set of dimensionally independent base units plus a set of derived units, formed by multiplication and division of the base units, that are by convention used with the unit system.
    * A user perhaps could issue a command to select a preferred unit system, or use the default (see below).
    * Auto unit system: The default unit system is updated on the fly anytime a unit is parsed. The corresponding unit in the default unit system is updated, so that answers are given in the same units the user supplies.
    */
-
-
   var UNIT_SYSTEMS = {
     si: {
       // Base units
@@ -3534,8 +3417,9 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
         prefix: PREFIXES.SHORT['']
       }
     }
-  }; // Clone to create the other unit systems
+  };
 
+  // Clone to create the other unit systems
   UNIT_SYSTEMS.cgs = JSON.parse(JSON.stringify(UNIT_SYSTEMS.si));
   UNIT_SYSTEMS.cgs.LENGTH = {
     unit: UNITS.m,
@@ -3552,7 +3436,8 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
   UNIT_SYSTEMS.cgs.ENERGY = {
     unit: UNITS.erg,
     prefix: PREFIXES.NONE['']
-  }; // there are wholly 4 unique cgs systems for electricity and magnetism,
+  };
+  // there are wholly 4 unique cgs systems for electricity and magnetism,
   // so let's not worry about it unless somebody complains
 
   UNIT_SYSTEMS.us = JSON.parse(JSON.stringify(UNIT_SYSTEMS.si));
@@ -3583,17 +3468,20 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
   UNIT_SYSTEMS.us.PRESSURE = {
     unit: UNITS.psi,
     prefix: PREFIXES.NONE['']
-  }; // Add additional unit systems here.
-  // Choose a unit system to seed the auto unit system.
+  };
 
-  UNIT_SYSTEMS.auto = JSON.parse(JSON.stringify(UNIT_SYSTEMS.si)); // Set the current unit system
+  // Add additional unit systems here.
 
+  // Choose a unit system to seed the auto unit system.
+  UNIT_SYSTEMS.auto = JSON.parse(JSON.stringify(UNIT_SYSTEMS.si));
+
+  // Set the current unit system
   var currentUnitSystem = UNIT_SYSTEMS.auto;
+
   /**
    * Set a unit system for formatting derived units.
    * @param {string} [name] The name of the unit system.
    */
-
   Unit.setUnitSystem = function (name) {
     if (hasOwnProperty(UNIT_SYSTEMS, name)) {
       currentUnitSystem = UNIT_SYSTEMS[name];
@@ -3601,12 +3489,11 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
       throw new Error('Unit system ' + name + ' does not exist. Choices are: ' + Object.keys(UNIT_SYSTEMS).join(', '));
     }
   };
+
   /**
    * Return the current unit system.
    * @return {string} The current unit system.
    */
-
-
   Unit.getUnitSystem = function () {
     for (var _key in UNIT_SYSTEMS) {
       if (hasOwnProperty(UNIT_SYSTEMS, _key)) {
@@ -3616,14 +3503,14 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
       }
     }
   };
+
   /**
    * Converters to convert from number to an other numeric type like BigNumber
    * or Fraction
    */
-
-
   Unit.typeConverters = {
     BigNumber: function BigNumber(x) {
+      if (x !== null && x !== void 0 && x.isFraction) return new _BigNumber(x.n).div(x.d).times(x.s);
       return new _BigNumber(x + ''); // stringify to prevent constructor error
     },
     Fraction: function Fraction(x) {
@@ -3633,9 +3520,26 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
       return x;
     },
     number: function number(x) {
+      if (x !== null && x !== void 0 && x.isFraction) return _number(x);
       return x;
     }
   };
+
+  /**
+   * Retrieve the right converter function corresponding with this unit's
+   * value
+   *
+   * @memberof Unit
+   * @return {Function}
+   */
+  Unit.prototype._numberConverter = function () {
+    var convert = Unit.typeConverters[this.valueType()];
+    if (convert) {
+      return convert;
+    }
+    throw new TypeError('Unsupported Unit value type "' + this.valueType() + '"');
+  };
+
   /**
    * Retrieve the right convertor function corresponding with the type
    * of provided exampleValue.
@@ -3644,63 +3548,56 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
    *                        In case of an unknown type,
    * @return {Function}
    */
-
   Unit._getNumberConverter = function (type) {
     if (!Unit.typeConverters[type]) {
       throw new TypeError('Unsupported type "' + type + '"');
     }
-
     return Unit.typeConverters[type];
-  }; // Add dimensions to each built-in unit
-
+  };
 
+  // Add dimensions to each built-in unit
   for (var _key2 in UNITS) {
     if (hasOwnProperty(UNITS, _key2)) {
       var unit = UNITS[_key2];
       unit.dimensions = unit.base.dimensions;
     }
-  } // Create aliases
-
+  }
 
+  // Create aliases
   for (var _name2 in ALIASES) {
     if (hasOwnProperty(ALIASES, _name2)) {
       var _unit2 = UNITS[ALIASES[_name2]];
       var alias = {};
-
       for (var _key3 in _unit2) {
         if (hasOwnProperty(_unit2, _key3)) {
           alias[_key3] = _unit2[_key3];
         }
       }
-
       alias.name = _name2;
       UNITS[_name2] = alias;
     }
   }
+
   /**
    * Checks if a character is a valid latin letter (upper or lower case).
    * Note that this function can be overridden, for example to allow support of other alphabets.
    * @param {string} c Tested character
    */
-
-
   Unit.isValidAlpha = function isValidAlpha(c) {
     return /^[a-zA-Z]$/.test(c);
   };
-
   function assertUnitNameIsValid(name) {
     for (var i = 0; i < name.length; i++) {
       c = name.charAt(i);
-
       if (i === 0 && !Unit.isValidAlpha(c)) {
         throw new Error('Invalid unit name (must begin with alpha character): "' + name + '"');
       }
-
       if (i > 0 && !(Unit.isValidAlpha(c) || isDigit(c))) {
         throw new Error('Invalid unit name (only alphanumeric characters are allowed): "' + name + '"');
       }
     }
   }
+
   /**
    * Wrapper around createUnitSingle.
    * Example:
@@ -3719,39 +3616,35 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
    * @param {object} obj      Object map. Each key becomes a unit which is defined by its value.
    * @param {object} options
    */
-
-
   Unit.createUnit = function (obj, options) {
     if (typeof obj !== 'object') {
       throw new TypeError("createUnit expects first parameter to be of type 'Object'");
-    } // Remove all units and aliases we are overriding
-
+    }
 
+    // Remove all units and aliases we are overriding
     if (options && options.override) {
       for (var _key4 in obj) {
         if (hasOwnProperty(obj, _key4)) {
           Unit.deleteUnit(_key4);
         }
-
         if (obj[_key4].aliases) {
           for (var i = 0; i < obj[_key4].aliases.length; i++) {
             Unit.deleteUnit(obj[_key4].aliases[i]);
           }
         }
       }
-    } // TODO: traverse multiple times until all units have been added
-
+    }
 
+    // TODO: traverse multiple times until all units have been added
     var lastUnit;
-
     for (var _key5 in obj) {
       if (hasOwnProperty(obj, _key5)) {
         lastUnit = Unit.createUnitSingle(_key5, obj[_key5]);
       }
     }
-
     return lastUnit;
   };
+
   /**
    * Create a user-defined unit and register it with the Unit type.
    * Example:
@@ -3773,39 +3666,30 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
    *     base unit, the name of the newly create base unit. Otherwise, this property
    *     has no effect.
    *
-   * @param {Object} options   (optional) An object containing any of the following
-   * properties:
-   *   - override {boolean} Whether this unit should be allowed to override existing
-   *     units.
-   *
    * @return {Unit}
    */
-
-
-  Unit.createUnitSingle = function (name, obj, options) {
+  Unit.createUnitSingle = function (name, obj) {
     if (typeof obj === 'undefined' || obj === null) {
       obj = {};
     }
-
     if (typeof name !== 'string') {
       throw new TypeError("createUnitSingle expects first parameter to be of type 'string'");
-    } // Check collisions with existing units
-
+    }
 
+    // Check collisions with existing units
     if (hasOwnProperty(UNITS, name)) {
       throw new Error('Cannot create unit "' + name + '": a unit with that name already exists');
-    } // TODO: Validate name for collisions with other built-in functions (like abs or cos, for example), and for acceptable variable names. For example, '42' is probably not a valid unit. Nor is '%', since it is also an operator.
+    }
 
+    // TODO: Validate name for collisions with other built-in functions (like abs or cos, for example), and for acceptable variable names. For example, '42' is probably not a valid unit. Nor is '%', since it is also an operator.
 
     assertUnitNameIsValid(name);
     var defUnit = null; // The Unit from which the new unit will be created.
-
     var aliases = [];
     var offset = 0;
     var definition;
     var prefixes;
     var baseName;
-
     if (obj && obj.type === 'Unit') {
       defUnit = obj.clone();
     } else if (typeof obj === 'string') {
@@ -3817,14 +3701,12 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
       prefixes = obj.prefixes;
       offset = obj.offset;
       baseName = obj.baseName;
-
       if (obj.aliases) {
         aliases = obj.aliases.valueOf(); // aliases could be a Matrix, so convert to Array
       }
     } else {
       throw new TypeError('Cannot create unit "' + name + '" from "' + obj.toString() + '": expecting "string" or "Unit" or "Object"');
     }
-
     if (aliases) {
       for (var i = 0; i < aliases.length; i++) {
         if (hasOwnProperty(UNITS, aliases[i])) {
@@ -3832,7 +3714,6 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
         }
       }
     }
-
     if (definition && typeof definition === 'string' && !defUnit) {
       try {
         defUnit = Unit.parse(definition, {
@@ -3845,54 +3726,48 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
     } else if (definition && definition.type === 'Unit') {
       defUnit = definition.clone();
     }
-
     aliases = aliases || [];
     offset = offset || 0;
-
     if (prefixes && prefixes.toUpperCase) {
       prefixes = PREFIXES[prefixes.toUpperCase()] || PREFIXES.NONE;
     } else {
       prefixes = PREFIXES.NONE;
-    } // If defUnit is null, it is because the user did not
-    // specify a defintion. So create a new base dimension.
-
+    }
 
+    // If defUnit is null, it is because the user did not
+    // specify a defintion. So create a new base dimension.
     var newUnit = {};
-
     if (!defUnit) {
       // Add a new base dimension
       baseName = baseName || name + '_STUFF'; // foo --> foo_STUFF, or the essence of foo
-
       if (BASE_DIMENSIONS.indexOf(baseName) >= 0) {
         throw new Error('Cannot create new base unit "' + name + '": a base unit with that name already exists (and cannot be overridden)');
       }
+      BASE_DIMENSIONS.push(baseName);
 
-      BASE_DIMENSIONS.push(baseName); // Push 0 onto existing base units
-
+      // Push 0 onto existing base units
       for (var b in BASE_UNITS) {
         if (hasOwnProperty(BASE_UNITS, b)) {
           BASE_UNITS[b].dimensions[BASE_DIMENSIONS.length - 1] = 0;
         }
-      } // Add the new base unit
-
+      }
 
+      // Add the new base unit
       var newBaseUnit = {
         dimensions: []
       };
-
       for (var _i6 = 0; _i6 < BASE_DIMENSIONS.length; _i6++) {
         newBaseUnit.dimensions[_i6] = 0;
       }
-
       newBaseUnit.dimensions[BASE_DIMENSIONS.length - 1] = 1;
       newBaseUnit.key = baseName;
       BASE_UNITS[baseName] = newBaseUnit;
       newUnit = {
-        name: name,
+        name,
         value: 1,
         dimensions: BASE_UNITS[baseName].dimensions.slice(0),
-        prefixes: prefixes,
-        offset: offset,
+        prefixes,
+        offset,
         base: BASE_UNITS[baseName]
       };
       currentUnitSystem[baseName] = {
@@ -3901,26 +3776,24 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
       };
     } else {
       newUnit = {
-        name: name,
+        name,
         value: defUnit.value,
         dimensions: defUnit.dimensions.slice(0),
-        prefixes: prefixes,
-        offset: offset
-      }; // Create a new base if no matching base exists
+        prefixes,
+        offset
+      };
 
+      // Create a new base if no matching base exists
       var anyMatch = false;
-
       for (var _i7 in BASE_UNITS) {
         if (hasOwnProperty(BASE_UNITS, _i7)) {
           var match = true;
-
           for (var j = 0; j < BASE_DIMENSIONS.length; j++) {
             if (Math.abs((newUnit.dimensions[j] || 0) - (BASE_UNITS[_i7].dimensions[j] || 0)) > 1e-12) {
               match = false;
               break;
             }
           }
-
           if (match) {
             anyMatch = true;
             newUnit.base = BASE_UNITS[_i7];
@@ -3928,11 +3801,9 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
           }
         }
       }
-
       if (!anyMatch) {
         baseName = baseName || name + '_STUFF'; // foo --> foo_STUFF, or the essence of foo
         // Add the new base unit
-
         var _newBaseUnit = {
           dimensions: defUnit.dimensions.slice(0)
         };
@@ -3945,31 +3816,28 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, (_ref) =
         newUnit.base = BASE_UNITS[baseName];
       }
     }
-
     Unit.UNITS[name] = newUnit;
-
     for (var _i8 = 0; _i8 < aliases.length; _i8++) {
       var aliasName = aliases[_i8];
       var _alias = {};
-
       for (var _key6 in newUnit) {
         if (hasOwnProperty(newUnit, _key6)) {
           _alias[_key6] = newUnit[_key6];
         }
       }
-
       _alias.name = aliasName;
       Unit.UNITS[aliasName] = _alias;
     }
-
+    // delete the memoization cache, since adding a new unit to the array
+    // invalidates all old results
+    delete _findUnit.cache;
     return new Unit(null, name);
   };
-
   Unit.deleteUnit = function (name) {
     delete Unit.UNITS[name];
-  }; // expose arrays with prefixes, dimensions, units, systems
-
+  };
 
+  // expose arrays with prefixes, dimensions, units, systems
   Unit.PREFIXES = PREFIXES;
   Unit.BASE_DIMENSIONS = BASE_DIMENSIONS;
   Unit.BASE_UNITS = BASE_UNITS;