@oliasoft-open-source/units 4.7.0 → 5.0.0

package/dist/units-DNoJOeDf.js

@@ -1,2649 +0,0 @@
-import Fraction from 'fraction.js';
-
-const options = { maximumFractionDigits: 20 };
-function convertNumberToLocale(number, countryCode) {
-  let numberFormat;
-  try {
-    if (countryCode) {
-      numberFormat = new Intl.NumberFormat(countryCode, options);
-    }
-  } catch {
-    numberFormat = new Intl.NumberFormat(void 0, options);
-  }
-  return numberFormat.format(number);
-}
-
-const parseValue = (value) => {
-  const isString = typeof value === "string";
-  const hasUnit = isString && isValueWithUnit(value);
-  return hasUnit ? getValue(value) : value;
-};
-const isValidNum = (value) => {
-  const parsedValue = parseValue(value);
-  if (isEmptyString(parsedValue) || Number.isNaN(parsedValue) || parsedValue === Infinity || parsedValue === -Infinity) {
-    return true;
-  } else {
-    if (!(isNull(parsedValue) || isUndefined(parsedValue) || isTrailingPeriodSeparator(parsedValue) || isTrailingCommaSeparator(parsedValue) || isArray(parsedValue) || isObject(parsedValue))) {
-      const cleanedValue = cleanNumStr(String(parsedValue));
-      if (cleanedValue.includes(SEPARATOR)) {
-        return false;
-      }
-      const number = isFraction(cleanedValue) ? numFraction(cleanedValue) : isNumeric(cleanedValue) ? parseFloat(cleanedValue) : cleanedValue;
-      if (number === Infinity || number === -Infinity) {
-        return true;
-      }
-      if (!isNumeric(number)) {
-        return false;
-      }
-      if (!Number.isNaN(number)) {
-        return true;
-      }
-    }
-  }
-  return false;
-};
-const isScientificStringNum = (value) => {
-  if (typeof value === "string") {
-    return isValidNum(value) && value.toLowerCase().includes("e");
-  }
-  return false;
-};
-const toNum = (value, fallback, minimum) => {
-  const fallbackResult = fallback ?? value;
-  const parsedValue = parseValue(value);
-  if (!isValidNum(parsedValue)) {
-    return fallbackResult;
-  } else {
-    const cleanedValue = cleanNumStr(String(parsedValue));
-    const number = isFraction(cleanedValue) ? numFraction(cleanedValue) : isNumeric(cleanedValue) ? parseFloat(cleanedValue) : cleanedValue;
-    if (number === Infinity || number === -Infinity) {
-      return number;
-    }
-    if (Number.isNaN(number) || !isNumeric(number)) {
-      return fallbackResult;
-    } else if (minimum && number < minimum) {
-      return minimum;
-    }
-    return number;
-  }
-};
-const toString = (value) => {
-  if (isValidNum(value)) {
-    if (typeof value === "string") {
-      return value;
-    }
-    if (typeof value === "number") {
-      if (Number.isNaN(value) || !Number.isFinite(value)) {
-        return String(value);
-      }
-      return formatDecimalDisplayNumber(value, { noThousandsSeparator: true });
-    }
-  }
-  return value;
-};
-
-const countTrailingZeros = (value, decimalPartOnly = false) => {
-  const condition = decimalPartOnly ? /0+((?=[|eE])|$)/ : /(0+|0+\.0+)((?=[|eE])|$)/;
-  if (typeof value === "string" && (decimalPartOnly ? value.includes(".") || value.includes(",") : true)) {
-    return value?.match(condition)?.[0]?.replaceAll(/[.,]/g, "")?.length ?? 0;
-  }
-  return 0;
-};
-const hasTrailingZeros = (value) => {
-  return countTrailingZeros(value) > 0;
-};
-const parseNumber = (value, preserveTrailingZeros = false) => {
-  const isString = typeof value === "string";
-  const hasUnit = isString && isValueWithUnit(value);
-  const unit = hasUnit ? getUnit(value) : null;
-  const cleaned = cleanNumStr(hasUnit ? getValue(value) : value);
-  const number = preserveTrailingZeros && hasTrailingZeros(value) ? cleaned : toNum(cleaned);
-  return {
-    number,
-    unit,
-    isString
-  };
-};
-const safeStringifyNumber = (value, isScientific) => {
-  return isScientific ? String(value) : String(toString(value));
-};
-const unParseNumber = ({
-  value,
-  unit,
-  isString,
-  isScientific
-}) => {
-  const convertedValue = typeof value === "number" && isString ? safeStringifyNumber(value, isScientific) : value;
-  if (unit) {
-    return withUnit(convertedValue, unit);
-  }
-  return convertedValue;
-};
-
-const DEFAULT_MAX_RELATIVE_DIFF = Number.EPSILON;
-const convertNumbers = (firstValue, secondValue) => {
-  const { number: firstNumber, unit: firstUnit } = parseNumber(firstValue);
-  const { number: secondNumber, unit: secondUnit } = parseNumber(secondValue);
-  const differentUnits = firstUnit && secondUnit && firstUnit !== secondUnit;
-  const convertedSecondNumber = differentUnits ? convertAndGetValue(secondNumber, firstUnit, secondUnit) : secondNumber;
-  return {
-    firstNumber,
-    secondNumber: convertedSecondNumber
-  };
-};
-const getToleranceNumber = (relativeDiff) => {
-  if (relativeDiff !== null && relativeDiff !== void 0) {
-    if (isNumeric(relativeDiff) && typeof relativeDiff === "number") {
-      return relativeDiff;
-    }
-    if (isPercentage(relativeDiff)) {
-      const percentageValue = toNum(relativeDiff?.toString().replace("%", ""));
-      if (isNumeric(percentageValue)) {
-        return percentageValue / 100;
-      }
-    }
-  }
-  return null;
-};
-const isCloseTo = (firstValue, secondValue, options = { relativeDiff: DEFAULT_MAX_RELATIVE_DIFF }) => {
-  const { relativeDiff, absoluteDiff } = options;
-  const diff = relativeDiff ?? absoluteDiff;
-  const toleranceNumber = getToleranceNumber(diff);
-  if (firstValue === null || secondValue === null) {
-    return false;
-  }
-  const hasUnitFirstValue = isValueWithUnit(firstValue);
-  const hasUnitSecondValue = isValueWithUnit(secondValue);
-  if (hasUnitFirstValue && !hasUnitSecondValue || !hasUnitFirstValue && hasUnitSecondValue) {
-    throw new Error(
-      `Parameters must either both have units or both not have units. Received "${firstValue}" and "${secondValue}"`
-    );
-  }
-  if (toleranceNumber === null) {
-    console.warn("Tolerance number is not defined!");
-    return firstValue === secondValue;
-  }
-  if (toleranceNumber <= 0 || toleranceNumber < Number.EPSILON) {
-    throw Error(
-      "Unpredictable results - toleranceNumber should be bigger than zero or less then EPSILON"
-    );
-  }
-  const { firstNumber, secondNumber } = convertNumbers(firstValue, secondValue);
-  if ((firstNumber === Infinity || firstNumber === "Infinity") && (secondNumber === Infinity || secondNumber === "Infinity") || (firstNumber === -Infinity || firstNumber === "-Infinity") && (secondNumber === -Infinity || secondNumber === "-Infinity")) {
-    return true;
-  }
-  if (typeof firstNumber === "number" && typeof secondNumber === "number") {
-    if (firstNumber === secondNumber) return true;
-    if (absoluteDiff || firstNumber === 0 || secondNumber === 0) {
-      const diff2 = Math.abs(firstNumber - secondNumber);
-      return isCloseTo(diff2, toleranceNumber, { relativeDiff: "1%" }) || diff2 < toleranceNumber;
-    } else {
-      return 2 * Math.abs(
-        (firstNumber - secondNumber) / (firstNumber + secondNumber)
-      ) < toleranceNumber;
-    }
-  }
-  return false;
-};
-const isCloseToOrGreaterThan = (firstValue, secondValue, options = { relativeDiff: DEFAULT_MAX_RELATIVE_DIFF }) => {
-  if (firstValue === null || secondValue === null) {
-    return false;
-  }
-  const { firstNumber, secondNumber } = convertNumbers(firstValue, secondValue);
-  if (typeof firstNumber === "number" && typeof secondNumber === "number") {
-    return isCloseTo(firstNumber, secondNumber, options) || firstNumber > secondNumber;
-  }
-  return false;
-};
-const isCloseToOrLessThan = (firstValue, secondValue, options = { relativeDiff: DEFAULT_MAX_RELATIVE_DIFF }) => {
-  if (firstValue === null || secondValue === null) {
-    return false;
-  }
-  const { firstNumber, secondNumber } = convertNumbers(firstValue, secondValue);
-  if (typeof firstNumber === "number" && typeof secondNumber === "number") {
-    return isCloseTo(firstNumber, secondNumber, options) || firstNumber < secondNumber;
-  }
-  return false;
-};
-const isDeepCloseTo = (a, b, options = { relativeDiff: DEFAULT_MAX_RELATIVE_DIFF }) => {
-  if (Array.isArray(a) && Array.isArray(b)) {
-    if (a.length !== b.length) {
-      return false;
-    }
-    return a.every((a2, i) => isDeepCloseTo(a2, b[i], options));
-  }
-  if (typeof a === "object" && a !== null && typeof b === "object" && b !== null) {
-    const aKeys = Object.keys(a);
-    const bKeys = Object.keys(b);
-    if (aKeys.length !== bKeys.length) {
-      return false;
-    }
-    return aKeys.every((key) => isDeepCloseTo(a[key], b[key], options));
-  }
-  if (Number.isNaN(a) && Number.isNaN(b) || a === "" && b === "") {
-    return true;
-  }
-  if (typeof a === "number" && typeof b === "number" || isValueWithUnit(a) && isValueWithUnit(b) || isValidNum(a) && isValidNum(b)) {
-    return isCloseTo(a, b, options);
-  }
-  return true;
-};
-
-const DEFAULT_SIGNIFICANT_DIGITS = 4;
-const roundNumber = (value, n = DEFAULT_SIGNIFICANT_DIGITS) => {
-  const factor = 10 ** n;
-  return Math.round(value * factor) / factor;
-};
-const round = (value, n = DEFAULT_SIGNIFICANT_DIGITS) => {
-  if (typeof value === "number") {
-    return roundNumber(value, n);
-  }
-  if (value === null || Number.isNaN(value) || value === Infinity || value === -Infinity || value === void 0) {
-    return value;
-  }
-  const { number, unit, isString } = parseNumber(value);
-  const result = !isNumeric(number) || typeof number === "string" && number.endsWith(".") ? value : roundNumber(number, n);
-  return unParseNumber({
-    value: result,
-    unit,
-    isString,
-    isScientific: isScientificStringNum(value)
-  });
-};
-const roundNumberToPrecision = (value, n = DEFAULT_SIGNIFICANT_DIGITS) => {
-  return Number(value.toPrecision(n));
-};
-const roundNumberToFixedPrecision = (value, n = DEFAULT_SIGNIFICANT_DIGITS) => {
-  const roundedValue = toNum(value).toPrecision(n);
-  const [integerPart, decimalPart] = roundedValue.split(".");
-  if (decimalPart) {
-    const decimalDigits = n - integerPart.length;
-    return `${integerPart}.${decimalPart.padEnd(decimalDigits, "0")}`;
-  } else {
-    return integerPart;
-  }
-};
-const roundNumberToDecimalPrecision = (value, n = DEFAULT_SIGNIFICANT_DIGITS) => {
-  if (Math.abs(value) > 1) {
-    const [integerPart, decimalPart] = formatDecimal(value, "").split(".");
-    if (!decimalPart) {
-      return value;
-    } else {
-      const roundedDecimalPart = Number(`0.${decimalPart}`).toPrecision(n).slice(1);
-      return Number(integerPart + roundedDecimalPart);
-    }
-  }
-  return roundNumberToPrecision(value, n);
-};
-const roundToPrecision = (value, n = DEFAULT_SIGNIFICANT_DIGITS) => {
-  if (typeof value === "number") {
-    return roundNumberToPrecision(value, n);
-  }
-  if (value === null || Number.isNaN(value) || value === Infinity || value === -Infinity || value === void 0) {
-    return value;
-  }
-  const { number, unit, isString } = parseNumber(value);
-  const result = !isNumeric(number) || typeof number === "string" && number.endsWith(".") ? value : roundNumberToPrecision(number, n);
-  return unParseNumber({
-    value: result,
-    unit,
-    isString,
-    isScientific: isScientificStringNum(value)
-  });
-};
-const roundToDecimalPrecision = (value, n = DEFAULT_SIGNIFICANT_DIGITS) => {
-  if (typeof value === "number") {
-    return roundNumberToDecimalPrecision(value, n);
-  }
-  if (value === null || Number.isNaN(value) || value === Infinity || value === -Infinity || value === void 0) {
-    return value;
-  }
-  const { number, unit, isString } = parseNumber(value);
-  const result = !isNumeric(number) || typeof number === "string" && number.endsWith(".") ? value : roundNumberToDecimalPrecision(number, n);
-  return unParseNumber({
-    value: result,
-    unit,
-    isString,
-    isScientific: isScientificStringNum(value)
-  });
-};
-const roundNumberByMagnitude = (value, n = DEFAULT_SIGNIFICANT_DIGITS, toFixed = false) => {
-  const noDecimalsAbove = 10 ** n;
-  const result = noDecimalsAbove && value > noDecimalsAbove ? roundNumber(value, 0) : toFixed ? roundNumberToFixedPrecision(value, n) : (
-    //for comparison, old implementation from toPretty (functionally equivalent to new implementation, see tests)
-    //return Number(value.toExponential(n - 1).toString());
-    roundNumberToPrecision(value, n)
-  );
-  return toFixed ? String(result) : result;
-};
-const roundByMagnitude = (value, n = DEFAULT_SIGNIFICANT_DIGITS) => {
-  if (typeof value === "number") {
-    return roundNumberByMagnitude(value, n);
-  }
-  if (value === null || Number.isNaN(value) || value === Infinity || value === -Infinity || value === void 0) {
-    return value;
-  }
-  const { number, unit, isString } = parseNumber(value);
-  const result = !isNumeric(number) || typeof number === "string" && number.endsWith(".") ? value : roundNumberByMagnitude(number, n);
-  return unParseNumber({
-    value: result,
-    unit,
-    isString,
-    isScientific: isScientificStringNum(value)
-  });
-};
-const roundByMagnitudeToFixed = (value, n = DEFAULT_SIGNIFICANT_DIGITS) => {
-  const toFixed = true;
-  if (value === null || Number.isNaN(value) || value === Infinity || value === -Infinity || value === void 0) {
-    return value;
-  }
-  if (typeof value === "number") {
-    return roundNumberByMagnitude(value, n, toFixed);
-  }
-  const { number, unit } = parseNumber(value, true);
-  const result = !isNumeric(number) || typeof number === "string" && number.endsWith(".") ? value : roundNumberByMagnitude(number, n, toFixed);
-  return unParseNumber({
-    value: result,
-    unit,
-    isString: true,
-    isScientific: isScientificStringNum(value)
-  });
-};
-const roundNumberByRange = (value, min, max, n = DEFAULT_SIGNIFICANT_DIGITS) => {
-  if (isCloseToOrLessThan(max, min)) {
-    return value;
-  }
-  const range = max - min;
-  const scale = Math.floor(Math.log10(range));
-  const precision = Math.max(n, 0 - scale);
-  return roundNumber(value, precision);
-};
-const roundByRange = (value, min, max, n = DEFAULT_SIGNIFICANT_DIGITS) => {
-  if (typeof value === "number") {
-    return roundNumberByRange(value, min, max, n);
-  }
-  if (value === null || Number.isNaN(value) || value === Infinity || value === -Infinity || value === void 0) {
-    return value;
-  }
-  const { number, unit, isString } = parseNumber(value);
-  const result = !isNumeric(number) || typeof number === "string" && number.endsWith(".") ? value : roundNumberByRange(number, min, max, n);
-  return unParseNumber({
-    value: result,
-    unit,
-    isString,
-    isScientific: isScientificStringNum(value)
-  });
-};
-const roundToFixed = (value, n = DEFAULT_SIGNIFICANT_DIGITS) => {
-  if (value === null || Number.isNaN(value) || value === Infinity || value === -Infinity || value === void 0) {
-    return value;
-  }
-  if (typeof value === "number") {
-    return value.toFixed(n);
-  }
-  const { number, unit, isString } = parseNumber(value);
-  const result = !isNumeric(number) || typeof number === "string" && number.endsWith(".") ? value : number.toFixed(n);
-  return unParseNumber({
-    value: result,
-    unit,
-    isString,
-    isScientific: isScientificStringNum(value)
-  });
-};
-
-const DEFAULT_AUTO_SCIENTIFIC_BELOW = 1e-4;
-const DEFAULT_AUTO_SCIENTIFIC_ABOVE = 1e7;
-const superscriptSymbols = {
-  "0": "\u2070",
-  "1": "\xB9",
-  "2": "\xB2",
-  "3": "\xB3",
-  "4": "\u2074",
-  "5": "\u2075",
-  "6": "\u2076",
-  "7": "\u2077",
-  "8": "\u2078",
-  "9": "\u2079",
-  "+": "\u207A",
-  "-": "\u207B"
-};
-const appendTrailingZeros = (value, numberOfZeros) => {
-  const zeros = "0".repeat(numberOfZeros);
-  return numberOfZeros > 0 && value !== "0" ? !value.includes(".") ? `${value}.${zeros}` : `${value}${zeros}` : value;
-};
-const formatDecimal = (value, thousandSeparator, preserveTrailingZeros = false) => {
-  const convertedValue = convertNumberToLocale(
-    toNum(value),
-    "en-US"
-  ).replaceAll(",", thousandSeparator);
-  return preserveTrailingZeros ? appendTrailingZeros(convertedValue, countTrailingZeros(value, true)) : convertedValue;
-};
-const formatDecimalDisplayNumber = (value, options) => {
-  const { nonBreakingSpace } = options ?? {};
-  if (value === "") {
-    return value;
-  }
-  if (value === null || value === void 0) {
-    return "";
-  }
-  if (!isValidNum(value)) {
-    return trim(value.toString());
-  }
-  const space = options?.noThousandsSeparator ? "" : nonBreakingSpace ? "\u2007" : " ";
-  return formatDecimal(value, space, options?.preserveTrailingZeros);
-};
-const formatScientificDisplayNumber = (value, options) => {
-  const { roundScientificCoefficient, eNotation } = options ?? {};
-  if (Number.isNaN(value)) {
-    return "Invalid";
-  }
-  if (value === null || value === void 0) {
-    return "";
-  }
-  if (!isValidNum(value) || value === "") {
-    return trim(value.toString());
-  }
-  const sanitizedValue = toNum(value);
-  if (!Number.isFinite(sanitizedValue)) {
-    return trim(value.toString());
-  }
-  const power = eNotation ? "e" : "\xB710";
-  const [coefficient, exponent] = sanitizedValue.toExponential().split("e");
-  const roundedCoefficient = typeof roundScientificCoefficient === "number" ? round(coefficient, roundScientificCoefficient) : coefficient;
-  const noExponent = exponent === "+0" || exponent === "-0";
-  const formattedExponent = [...exponent.replaceAll("+", "")].map((c) => eNotation ? c : superscriptSymbols[c]).join("");
-  return noExponent ? roundedCoefficient : `${roundedCoefficient}${power}${formattedExponent}`;
-};
-const formatDisplayNumber = (value, options) => {
-  const abs = Math.abs(toNum(value));
-  const formatScientific = options?.scientific === "auto" && options?.autoScientificBelow && options?.autoScientificAbove ? abs < options?.autoScientificBelow || abs > options?.autoScientificAbove : options?.scientific;
-  return formatScientific ? formatScientificDisplayNumber(value, options) : formatDecimalDisplayNumber(value, options);
-};
-const displayNumber = (value, options) => {
-  const optionsWithDefaults = {
-    scientific: options?.scientific ?? "auto",
-    eNotation: options?.eNotation ?? false,
-    autoScientificBelow: options?.autoScientificBelow ?? DEFAULT_AUTO_SCIENTIFIC_BELOW,
-    autoScientificAbove: options?.autoScientificAbove ?? DEFAULT_AUTO_SCIENTIFIC_ABOVE,
-    withUnit: options?.withUnit ?? false,
-    nonBreakingSpace: options?.nonBreakingSpace ?? false,
-    roundScientificCoefficient: options?.roundScientificCoefficient
-  };
-  const { withUnit } = optionsWithDefaults;
-  if (value === null || value === void 0) {
-    return "";
-  }
-  const { number, unit } = parseNumber(value);
-  const formattedNumber = formatDisplayNumber(number, optionsWithDefaults);
-  const formattedUnit = unit ? LABELS?.[unit] : "";
-  return withUnit && unit ? formattedNumber === "" ? formattedUnit : `${formattedNumber} ${formattedUnit}` : formattedNumber;
-};
-const displayNumberToFixed = (value, options) => {
-  const optionsWithDefaults = {
-    scientific: options?.scientific ?? "auto",
-    eNotation: options?.eNotation ?? false,
-    autoScientificBelow: options?.autoScientificBelow ?? DEFAULT_AUTO_SCIENTIFIC_BELOW,
-    autoScientificAbove: options?.autoScientificAbove ?? DEFAULT_AUTO_SCIENTIFIC_ABOVE,
-    withUnit: options?.withUnit ?? false,
-    nonBreakingSpace: options?.nonBreakingSpace ?? false,
-    roundScientificCoefficient: options?.roundScientificCoefficient
-  };
-  const { withUnit } = optionsWithDefaults;
-  if (value === null || value === void 0) {
-    return "";
-  }
-  const preserveTrailingZeros = true;
-  const { number, unit } = parseNumber(value, preserveTrailingZeros);
-  const formattedNumber = formatDisplayNumber(number, {
-    ...optionsWithDefaults,
-    preserveTrailingZeros: true
-  });
-  const formattedUnit = unit ? LABELS?.[unit] : "";
-  return withUnit && unit ? formattedNumber === "" ? formattedUnit : `${formattedNumber} ${formattedUnit}` : formattedNumber;
-};
-
-const isNull = (str) => str === null;
-const isUndefined = (str) => str === void 0;
-const isArray = (str) => str && str.constructor === Array;
-const isObject = (str) => str && str.constructor === Object;
-const isEmptyString = (str) => str === "";
-const isTrailingPeriodSeparator = (str) => str && str[str.length - 1] === ".";
-const isTrailingCommaSeparator = (str) => str && str[str.length - 1] === ",";
-const isPercentage = (value) => typeof value === "string" && /^\d+(\.\d+)?%$/.test(value);
-function isEmptyValueWithUnit(val) {
-  return typeof val === "string" && val.length > 0 && val.startsWith("|");
-}
-const trimWhiteSpace = (value) => value.trim().replace(/\s+/g, " ");
-const isFraction = (value) => {
-  if (typeof value !== "string") {
-    return false;
-  }
-  if (!value.includes("/")) {
-    return false;
-  }
-  try {
-    new Fraction(trimWhiteSpace(value));
-    return true;
-  } catch (error) {
-    return error.message === "Division by Zero";
-  }
-};
-function isNumeric(v) {
-  if (v === void 0 || v === null || Array.isArray(v) || typeof v === "object" || Number.isNaN(v) || v === "NaN" || v === Infinity || v === -Infinity || v === "Infinity" || v === "-Infinity") {
-    return false;
-  }
-  if (isFraction(v)) {
-    return true;
-  }
-  const parsed = parseFloat(v);
-  return typeof v === "string" ? !isNaN(parsed) && (EXP_NOTATION_RE.test(v) || isFinite(v)) : isFinite(v);
-}
-function allNumbers(arr) {
-  return !arr.some((val) => typeof val !== "number");
-}
-const formatNumber = (number) => displayNumber(number);
-function charCount(chr, str) {
-  const single_char = (chr + "")[0];
-  let total = 0;
-  let last_location = str.indexOf(single_char, 0) + 1;
-  while (last_location > 0) {
-    last_location = str.indexOf(single_char, last_location) + 1;
-    total += 1;
-  }
-  return total;
-}
-function getNumberOfDigitsToShow(num, maxNumDigits = 20) {
-  const defaultDigits = Math.min(4, maxNumDigits);
-  let digits = defaultDigits;
-  if (typeof num !== "number") {
-    return defaultDigits;
-  }
-  const numStr = String(num);
-  const RegExForExponentialNumber = /-?[0-9.,]*[Ee]-?[0-9]+/;
-  if (RegExForExponentialNumber.test(numStr)) {
-    while (Math.abs(num) * 10 ** digits < 1 && digits < maxNumDigits) {
-      digits++;
-    }
-    return Math.min(digits + (defaultDigits - 1), maxNumDigits);
-  }
-  if (num > 1 || num < -1) {
-    return defaultDigits;
-  }
-  for (let i = 2; i < numStr.length; i++) {
-    const element = numStr[i];
-    if (element !== "0") {
-      return Math.min(maxNumDigits, digits + i - 2);
-    }
-  }
-  return digits;
-}
-function fraction(str) {
-  if (str instanceof Array || str === null || str === void 0) {
-    return NaN;
-  }
-  if (typeof str === "string") {
-    str = trimWhiteSpace(str);
-  }
-  if (str === "") {
-    return NaN;
-  }
-  let result = NaN;
-  let infinite = false;
-  try {
-    const fractionObject = new Fraction(str);
-    if (fractionObject !== void 0) {
-      result = fractionObject.valueOf();
-    }
-  } catch (e) {
-    if (e instanceof Error && e.message === "Division by Zero") {
-      infinite = true;
-    }
-  }
-  return infinite ? Infinity : result;
-}
-function asFraction(str) {
-  if (typeof str === "string") {
-    str = trimWhiteSpace(str);
-  }
-  if (str === "") {
-    str = "0";
-  }
-  return new Fraction(str).toFraction(true);
-}
-function numFraction(str) {
-  if (str instanceof Array || str === null || str === void 0 || str === "" || str === Infinity || str === -Infinity || str === "Infinity" || str === "-Infinity" || Number.isNaN(str) || str === "NaN") {
-    return str;
-  }
-  if (typeof str === "string") {
-    str = trimWhiteSpace(str);
-  }
-  let result = str;
-  try {
-    const fractionObject = new Fraction(str);
-    if (fractionObject !== void 0) {
-      result = fractionObject.valueOf();
-    }
-  } catch (error) {
-    if (error.message === "Division by Zero") {
-      const minus = str.charAt(0) === "-";
-      return minus ? -Infinity : Infinity;
-    }
-    console.warn("Error in numFraction() method: ", str);
-  }
-  return result.valueOf();
-}
-const trim = (value) => value.trim().replace(/[\t\r\n]/g, "");
-function cleanNumStr(str) {
-  let cleanString = trim(str + "");
-  const slashCount = charCount("/", cleanString);
-  const spaceCount = charCount(" ", cleanString) + charCount("\xA0", cleanString);
-  let dotcount = charCount(".", cleanString);
-  let commacount = charCount(",", cleanString);
-  if (slashCount === 0 && spaceCount > 0) {
-    cleanString = cleanString.replace(/\s/g, "");
-  }
-  if (commacount > 1) {
-    cleanString = cleanString.replace(/,/g, "");
-  }
-  if (dotcount > 1) {
-    cleanString = cleanString.replace(/\./g, "");
-  }
-  commacount = charCount(",", cleanString);
-  dotcount = charCount(".", cleanString);
-  if (dotcount === 1 && commacount === 1) {
-    if (cleanString.indexOf(",") > cleanString.indexOf(".")) {
-      cleanString = cleanString.replace(".", "");
-      cleanString = cleanString.replace(",", ".");
-    } else {
-      cleanString = cleanString.replace(",", "");
-    }
-    if (cleanString.indexOf(".") === 0) {
-      cleanString = 0 + cleanString;
-    }
-    return cleanString;
-  }
-  if (!dotcount && commacount) {
-    cleanString = cleanString.replace(",", ".");
-  }
-  if (cleanString.indexOf(".") === 0) {
-    cleanString = 0 + cleanString;
-  }
-  return cleanString;
-}
-const stripLeadingZeros = (value) => {
-  const isMinus = value?.[0] === "-";
-  const matchMinus = /^-/gm;
-  const matchLeadingZeros = /^(?:0+(?=[1-9])|0+(?=0))/gm;
-  const cleanedValue = value.replace(matchMinus, "").replace(matchLeadingZeros, "");
-  return isMinus ? `-${cleanedValue}` : cleanedValue;
-};
-function cleanNum(str) {
-  if (typeof str === "number") {
-    return str;
-  }
-  return parseFloat(cleanNumStr(str));
-}
-const isNonNumerical = (value) => !isNumeric(value);
-const { abs, exp, sqrt } = Math;
-function newton(f, df, x0, tol = 1e-8, max_iter = 30) {
-  let X = x0;
-  let iter = 0;
-  let err = 1;
-  while (err > tol && iter < max_iter) {
-    const X_new = X - f(X) / df(X);
-    err = abs(f(X_new) - f(X));
-    if (err < tol) {
-      return [X_new, true, iter];
-    } else {
-      X = X_new;
-    }
-    iter++;
-  }
-  return [x0, false, iter];
-}
-function erf(z) {
-  const t = 1 / (1 + 0.5 * abs(z));
-  const ans = 1 - t * exp(
-    -(z ** 2) - 1.26551223 + t * (1.00002368 + t * (0.37409196 + t * (0.09678418 + t * (-0.18628806 + t * (0.27886807 + t * (-1.13520398 + t * (1.48851587 + t * (-0.82215223 + t * 0.17087277))))))))
-  );
-  return z >= 0 ? ans : -ans;
-}
-function get_k_from_conf_int(a) {
-  const f = (k) => a - erf(k / sqrt(2));
-  const df = (k) => -sqrt(2 / Math.PI) * exp(-0.5 * k ** 2);
-  const [t0] = newton(f, df, 1);
-  return t0;
-}
-function get_conf_int_from_k(k) {
-  return erf(k / sqrt(2));
-}
-const normalizeExponent = (input) => {
-  return input.replace(
-    /^([+-]?(?:\d+\.?\d*|\.\d+))[ ]*[eE][ ]*([+-]?[ ]*\d+)/,
-    (_m, mantissa, exp2) => {
-      let m = mantissa.endsWith(".") ? mantissa.slice(0, -1) : mantissa;
-      if (m.startsWith(".")) m = "0" + m;
-      const e = exp2.replace(/[ ]+/g, "");
-      return `${m}e${e}`;
-    }
-  );
-};
-function normalizeScientific(val) {
-  if (typeof val !== "string") return val;
-  let s = val.replace(/\u00A0|\u2007|\u202F/g, " ").trim();
-  if (isValueWithUnit(s)) {
-    const [val2, unit] = split(s);
-    const fixedLeft = normalizeExponent(val2.trim());
-    return `${fixedLeft}|${unit.trim()}`;
-  }
-  const m = s.match(
-    /^([+-]?(?:\d+(?:\.\d*)?|\.\d+)\s*[eE]\s*[+-]?\s*\d+)\s+(.+)$/
-  );
-  if (m) return `${normalizeExponent(m[1])}|${m[2].trim()}`;
-  return normalizeExponent(s);
-}
-
-const LABELS = Object.freeze({
-  in: "in",
-  mm: "mm",
-  cm: "cm",
-  m: "m",
-  microM: "\u03BCm",
-  km: "km",
-  ft: "ft",
-  usft: "usft",
-  in2: "in\xB2",
-  cm2: "cm\xB2",
-  m2: "m\xB2",
-  kg: "kg",
-  tonnes: "t",
-  mt: "mt",
-  kip: "kip",
-  bbl: "bbl",
-  m3: "m\xB3",
-  Mm3: "Mm\xB3",
-  MMSCF: "MMSCF",
-  lbm: "lbm",
-  "kg/mol": "kg/mol",
-  "lbf/mol": "lbf/mol",
-  sg: "sg",
-  ppg: "ppg",
-  "kg/m3": "kg/m\xB3",
-  "lbm/ft3": "lbm/ft\xB3",
-  s: "s",
-  min: "min",
-  h: "h",
-  d: "d",
-  month: "month",
-  year: "year",
-  "bbl/ft": "bbl/ft",
-  lpm: "L/min",
-  lps: "L/s",
-  bpm: "bbl/min",
-  "m3/min": "m\xB3/min",
-  "m3/s": "m\xB3/s",
-  MMSCFD: "MMSCFD",
-  bar: "Bar",
-  Pa: "Pa",
-  kPa: "kPa",
-  MPa: "MPa",
-  GPa: "GPa",
-  kPsi: "Psi",
-  ksi: "ksi",
-  "lbf/100ft2": "lbf/100ft\xB2",
-  "1/Pa": "Pa\u207B\xB9",
-  "1/kPa": "kPa\u207B\xB9",
-  "1/MPa": "MPa\u207B\xB9",
-  "1/GPa": "GPa\u207B\xB9",
-  "1/psi": "psi\u207B\xB9",
-  "kPa/m": "kPa/m",
-  "1/bar": "bar\u207B\xB9",
-  klbf: "klbf",
-  "psi/ft": "Psi/ft",
-  "bar/100m": "bar/100m",
-  "psi/100ft": "psi/100ft",
-  "kPa/100m": "kPa/100m",
-  C: "\xB0C",
-  F: "\xB0F",
-  K: "K",
-  "C/100m": "\xB0C/100m",
-  "C/m": "\xB0C/m",
-  "Pa/C": "Pa/\xB0C",
-  "Bar/C": "Bar/\xB0C",
-  "psi/F": "psi/\xB0F",
-  "psi/C": "psi/\xB0C",
-  "F/100ft": "\xB0F/100ft",
-  "F/ft": "\xB0F/ft",
-  "K/100m": "K/100m",
-  "K/m": "K/m",
-  "lbf/ft": "lbf/ft",
-  N: "N",
-  kN: "kN",
-  "N/m": "N/m",
-  "daN/m": "daN/m",
-  lbf: "lbf",
-  kgf: "kgf",
-  rad: "rad",
-  "BTU/lbm": "BTU/lbm",
-  ppf: "ppf",
-  "kg/m": "kg/m",
-  "E-06/degC": "10\u207B\u2076/\xB0C",
-  "E-06/degF": "10\u207B\u2076/\xB0F",
-  "1/K": "K\u207B\xB9",
-  km2: "km\xB2",
-  ft2: "ft\xB2",
-  mm2: "mm\xB2",
-  mile2: "mile\xB2",
-  ft3: "ft\xB3",
-  "g/cm3": "g/cm\xB3",
-  Sm3: "Sm\xB3",
-  "ft3/s": "ft\xB3/s",
-  "ft3/d": "ft\xB3/d",
-  "m3/d": "m\xB3/d",
-  "1/m3/d": "1/m\xB3/d",
-  "s/m3": "s/m\xB3",
-  "1/MMSCFD": "1/MMSCFD",
-  "bbl/d": "bbl/d",
-  tonneForce: "tonne-force",
-  USGal: "US gal",
-  "g/mol": "g/mol",
-  Nm: "N\u22C5m",
-  kNm: "kN\u22C5m",
-  ftlbf: "ft\u22C5lbf",
-  "J/(kg*degC)": "J/(kg\u22C5\xB0C)",
-  "J/(kg*degK)": "J/(kg\u22C5K)",
-  "J/(s*m*degK)": "J/(s\u22C5m\u22C5K)",
-  "BTU/(lbm*degF)": "BTU/(lbm\u22C5\xB0F)",
-  "BTU/(h*ft*degF)": "BTU/(h\u22C5ft\u22C5\xB0F)",
-  l: "L",
-  "l/m": "L/m",
-  "kJ/kg": "kJ/kg",
-  "J/kg": "J/kg",
-  deg: "\xB0",
-  "W/(mK)": "W/(m\u22C5K)",
-  psi: "psi",
-  "deg/100ft": "\xB0/100ft",
-  "deg/30m": "\xB0/30m",
-  "deg/10m": "\xB0/10m",
-  "%": "%",
-  Hz: "Hz",
-  "1/s": "1/s",
-  rpm: "rpm",
-  "Pa/m": "Pa/m",
-  "bar/m": "bar/m",
-  gpm: "gpm",
-  "kg/s": "kg/s",
-  "lbm/s": "lbm/s",
-  "tonnes/h": "tonnes/h",
-  "tons/h": "tons/h",
-  "deg/m": "\xB0/m",
-  "deg/ft": "\xB0/ft",
-  "rad/m": "rad/m",
-  "rad/ft": "rad/ft",
-  "dyn/cm": "dyn/cm",
-  "mN/m": "mN/m",
-  "m/s": "m/s",
-  "ft/s": "ft/s",
-  "m/min": "m/min",
-  "ft/min": "ft/min",
-  "m/h": "m/h",
-  "ft/h": "ft/h",
-  mph: "mph",
-  "km/h": "km/h",
-  "m/s2": "m/s\xB2",
-  Gs: "Gs",
-  nT: "nT",
-  g: "g",
-  "ft/s2": "ft/s\xB2",
-  "Pa*s": "Pa\u22C5s",
-  P: "P",
-  "mPa*s": "mPa\u22C5s",
-  cP: "cP",
-  W: "W",
-  hhp: "hhp",
-  hp: "hp",
-  kW: "kW",
-  MW: "MW",
-  "BTU/h": "BTU/h",
-  "W/m2": "W/m\xB2",
-  "hhp/in2": "hhp/in\xB2",
-  "hhp/ft2": "hhp/ft\xB2",
-  "Mm3/d": "Mm\xB3/d",
-  "STB/d": "STB/d",
-  "Sm3/d": "Sm\xB3/d",
-  "Sm3/min": "Sm\xB3/min",
-  "MSm3/d": "MSm\xB3/d",
-  "SCF/STB": "SCF / STB",
-  "Sm3/Sm3": "Sm\xB3 / Sm\xB3",
-  "SCF/d": "SCF/d",
-  STB: "STB",
-  SCF: "SCF",
-  MSm3: "MSm\xB3",
-  Gsg: "sg",
-  Gppg: "ppg",
-  "Gkg/m3": "kg/m\xB3",
-  "Glbm/ft3": "lbm/ft\xB3",
-  "lb/ft3": "lb/ft\xB3",
-  "\xB0N": "\xB0N",
-  "\xB0S": "\xB0S",
-  "\xB0W": "\xB0W",
-  "\xB0E": "\xB0E",
-  fr: " ",
-  mD: "mD",
-  CI: "CI",
-  Sigma: "\u03C3",
-  "Sm3/d/bar": "Sm\xB3/d/bar",
-  "STB/d/psi": "STB/d/psi",
-  "m3/s/bar": "m\xB3/s/bar",
-  "lb/ft": "lb/ft",
-  "E-09/bar": "10\u207B\u2079/bar",
-  "E-10/psi": "10\u207B\xB9\u2070/psi",
-  "E-14/pa": "10\u207B\xB9\u2074/pa",
-  "m3/m": " m\xB3/m",
-  "cm3/m": "cm\xB3/m",
-  "mm3/m": "mm\xB3/m",
-  "ft3/ft": "ft\xB3/ft",
-  "in3/ft": "in\xB3/ft",
-  lk: "lk",
-  ftCla: "ftCla",
-  lkCla: "lkCla",
-  ftSe: "ftSe",
-  ydSe: "ydSe",
-  chSe: "chSe",
-  "chSe(T)": "chSe(T)",
-  ftGC: "ftGC",
-  ydInd: "ydInd",
-  "d/stand": "d/stand",
-  "h/stand": "h/stand",
-  "min/stand": "min/stand",
-  "s/stand": "s/stand",
-  "m3/t": "m3/t",
-  "L/100kg": "L/100kg"
-});
-const ALT_UNITS = Object.freeze({
-  acceleration: ["ft/s2", "m/s2"],
-  angleGradient: [
-    "deg/30m",
-    "rad/m",
-    "deg/m",
-    "deg/ft",
-    "rad/ft",
-    "deg/100ft",
-    "deg/10m"
-  ],
-  angles: ["deg", "rad"],
-  areaOther: ["in2", "ft2", "mm2", "cm2", "m2", "mile2", "km2"],
-  areaTubular: ["in2", "cm2", "ft2", "m2"],
-  blowoutFlowRate: [
-    "lpm",
-    "bpm",
-    "m3/min",
-    "ft3/s",
-    "m3/s",
-    "MMSCFD",
-    "ft3/d",
-    "m3/d",
-    "bbl/d",
-    "Mm3/d",
-    "STB/d",
-    "Sm3/d",
-    "Sm3/min",
-    "MSm3/d",
-    "SCF/d"
-  ],
-  blowoutGasFlowRate: ["MMSCFD", "Sm3/d", "MSm3/d", "SCF/d"],
-  blowoutOilFlowRate: ["Sm3/d", "Sm3/min", "STB/d"],
-  deg: ["deg", "rad"],
-  density: ["sg", "ppg", "kg/m3", "lbm/ft3", "g/cm3", "lb/ft3", "kPa/m"],
-  densityGas: ["Gsg", "Gppg", "Gkg/m3", "Glbm/ft3"],
-  densityOil: ["sg", "ppg", "kg/m3", "lbm/ft3"],
-  densityOilGas: ["ppg", "kg/m3", "lbm/ft3"],
-  densitySolid: ["sg", "ppg", "kg/m3", "lbm/ft3"],
-  depth: ["m", "ft"],
-  diameters: ["in", "m", "cm", "ft", "mm"],
-  distance: ["m", "ft"],
-  dls: ["deg/10m", "deg/30m", "deg/100ft"],
-  doglegSeverity: ["deg/10m", "deg/30m", "deg/100ft"],
-  duration: ["s", "h", "d", "min"],
-  durationShort: ["s", "min", "h", "d"],
-  durationLong: ["min", "h", "d", "month", "year"],
-  flowrate: [
-    "lpm",
-    "gpm",
-    "bpm",
-    "ft3/d",
-    "ft3/s",
-    "m3/s",
-    "m3/d",
-    "m3/min",
-    "Mm3/d",
-    "bbl/d",
-    "MMSCFD",
-    "STB/d",
-    "Sm3/d",
-    "Sm3/min",
-    "MSm3/d",
-    "SCF/d"
-  ],
-  fluidCompressibility: ["1/bar", "1/psi", "1/Pa", "1/kPa", "1/MPa", "1/GPa"],
-  force: ["tonnes", "lbf", "kgf", "N", "kN", "tonneForce", "klbf"],
-  forceGradient: ["lbf/ft", "N/m"],
-  frequency: ["Hz"],
-  gasVolume: ["MMSCF", "Sm3", "MSm3", "SCF"],
-  gor: ["Sm3/Sm3", "SCF/STB"],
-  height: ["m", "ft"],
-  intensity: ["W/m2", "hhp/in2", "hhp/ft2"],
-  interfacialTension: ["dyn/cm", "N/m", "lbf/ft", "mN/m"],
-  latitude: ["\xB0N", "\xB0S"],
-  length: ["m", "cm", "ft", "km", "in", "mm"],
-  linearCapacity: ["l/m", "bbl/ft"],
-  longitude: ["\xB0E", "\xB0W"],
-  massFlowRate: ["kg/s", "lbm/s", "tonnes/h", "tons/h"],
-  moleWeight: ["kg/mol", "lbf/mol", "g/mol"],
-  oilVolume: ["STB", "Sm3"],
-  percentage: ["%", "fr"],
-  permeability: ["mD", "m2"],
-  power: ["hp", "W", "hhp", "MW", "kW", "BTU/h"],
-  pressure: ["bar", "psi", "Pa", "kPa", "MPa", "ksi", "GPa", "lbf/100ft2"],
-  pressureGradient: [
-    "bar/100m",
-    "Pa/m",
-    "bar/m",
-    "psi/100ft",
-    "psi/ft",
-    "kPa/m"
-  ],
-  pressurechange: ["bar", "psi", "Pa", "MPa", "kPa"],
-  gasliftFlowRate: ["STB/d", "Sm3/d", "SCF/d"],
-  productionFlowRate: [
-    "MMSCFD",
-    "STB/d",
-    "Sm3/d",
-    "Sm3/min",
-    "MSm3/d",
-    "SCF/d"
-  ],
-  productionFlowRateOil: [
-    "MMSCFD",
-    "STB/d",
-    "Sm3/d",
-    "Sm3/min",
-    "MSm3/d",
-    "SCF/d"
-  ],
-  productionFlowRateGas: ["MMSCFD", "STB/d", "Sm3/d", "MSm3/d", "SCF/d"],
-  injectionFlowRate: [
-    "lpm",
-    "lps",
-    "bpm",
-    "gpm",
-    "MMSCFD",
-    "STB/d",
-    "Sm3/d",
-    "Sm3/min",
-    "MSm3/d",
-    "SCF/d"
-  ],
-  pumpRate: ["lpm", "lps", "bpm", "m3/s", "Sm3/min", "ft3/s", "gpm"],
-  rotationalSpeed: ["rpm", "Hz"],
-  roughness: ["m", "microM", "in"],
-  rpm: ["rpm", "Hz"],
-  sdstats: ["CI", "Sigma"],
-  specificHeatCapacity: ["J/(kg*degC)", "J/(kg*degK)", "BTU/(lbm*degF)"],
-  speed: ["km/h", "ft/min", "mph", "ft/h", "ft/s", "m/min", "m/s", "m/h"],
-  inverseStandSpeed: ["d/stand", "h/stand", "min/stand", "s/stand"],
-  rop: ["ft/h", "ft/min", "ft/s", "km/h", "m/h", "m/min", "m/s", "mph"],
-  stress: ["MPa", "kPa", "psi", "bar", "Pa", "ksi", "lbf/100ft2"],
-  temperature: ["C", "F", "K"],
-  pressurePerTemperature: ["Pa/C", "Bar/C", "psi/F", "psi/C"],
-  tempgrad: ["C/100m", "F/100ft", "K/100m", "C/m", "F/ft", "K/m"],
-  thermalConductivity: ["BTU/(h*ft*degF)", "W/(mK)"],
-  thermalExpansionCoefficient: ["E-06/degC", "E-06/degF", "1/K"],
-  torque: ["Nm", "ftlbf", "kNm"],
-  torqueGradient: ["N", "lbf", "tonnes"],
-  turbulentSkin: ["s/m3", "1/m3/d", "1/MMSCFD"],
-  viscosity: ["Pa*s", "P", "mPa*s", "cP"],
-  inflowProductivityIndex: ["Sm3/d/bar", "STB/d/psi", "m3/s/bar"],
-  volume: [
-    "m3",
-    "bbl",
-    "Mm3",
-    "l",
-    "USGal",
-    "ft3",
-    "STB",
-    "Sm3",
-    "MMSCF",
-    "MSm3",
-    "SCF"
-  ],
-  kickToleranceVolume: ["m3", "bbl", "USGal", "ft3", "STB", "Sm3", "SCF"],
-  weight: ["tonnes", "kg", "lbf", "mt", "kip", "N"],
-  weightGradient: ["ppf", "kg/m"],
-  wgrad: ["sg", "ppg"],
-  wltubulars: ["ppf", "kg/m"],
-  youngsModulus: ["Pa", "psi"],
-  massPerLength: ["kg/m", "lb/ft"],
-  wearFactor: ["E-09/bar", "E-10/psi", "E-14/pa"],
-  volumeGradient: ["m3/m", "cm3/m", "mm3/m", "ft3/ft", "in3/ft"],
-  shearStress: ["Pa", "lbf/100ft2"],
-  sensorAccelerometer: ["g", "m/s2"],
-  sensorMagnetometer: ["nT", "Gs"],
-  location: [
-    "lk",
-    "ftCla",
-    "lkCla",
-    "ftSe",
-    "ydSe",
-    "chSe",
-    "chSe(T)",
-    "ftGC",
-    "ydInd",
-    "ft",
-    "m",
-    "usft"
-  ],
-  mixingRequirements: ["m3/t", "L/100kg"],
-  entalphy: ["J/kg", "kJ/kg", "BTU/lbm"]
-});
-const UNIT_FROM_KEY = Object.freeze({
-  density: "sg",
-  densityGas: "Gsg",
-  densityOil: "sg",
-  densityOilGas: "kg/m3",
-  densitySolid: "kg/m3",
-  length: "m",
-  roughness: "m",
-  speed: "m/s",
-  diameters: "in",
-  duration: "s",
-  durationShort: "h",
-  durationLong: "d",
-  pressurechange: "bar",
-  pressure: "bar",
-  temperature: "C",
-  tempgrad: "C/100m",
-  volume: "m3",
-  kickToleranceVolume: "m3",
-  weight: "kg",
-  force: "N",
-  wgrad: "sg",
-  wltubulars: "ppf",
-  flowrate: "lpm",
-  permeability: "mD",
-  // MilliDarcy
-  interfacialTension: "dyn/cm",
-  // Dynes per centimeter
-  deg: "deg",
-  dls: "deg/30m",
-  percentage: "%",
-  latitude: "\xB0N",
-  longitude: "\xB0E",
-  torque: "Nm",
-  rpm: "rpm",
-  testSingleUnit: "m",
-  //test value for a unit with no alt_units
-  turbulentSkin: "1/m3/d",
-  pressurePerTemperature: "Pa/C",
-  sdstats: "Sigma",
-  acceleration: "m/s2",
-  massFlowRate: "kg/s",
-  angleGradient: "deg/m",
-  viscosity: "Pa*s",
-  weightGradient: "kg/m",
-  intensity: "W/m2",
-  gor: "Sm3/Sm3",
-  inflowProductivityIndex: "Sm3/d/bar",
-  wearFactor: "E-09/psi",
-  location: "m",
-  inverseStandSpeed: "s/stand",
-  mixingRequirements: "m3/t",
-  entalphy: "J/kg",
-  shearStress: "Pa",
-  volumeGradient: "m3/m",
-  sensorAccelerometer: "g",
-  sensorMagnetometer: "Gs"
-});
-const C = Object.freeze({
-  g: 0.0980665175317196,
-  ft_to_m: 0.3048,
-  inch_to_m: 0.0254,
-  lbf_to_kg: 0.45359237,
-  // https://en.wikipedia.org/wiki/Pound_(force)
-  kg_to_lbf: 2.20462262184877,
-  // https://en.wikipedia.org/wiki/Pound_(force)
-  ppf_to_kgm: 0.45359237 / 0.3048,
-  kg_cm3: 0.0293984025938081,
-  bar_to_psi: 14.503773773022,
-  // https://en.wikipedia.org/wiki/Pound_per_square_inch
-  bar_to_pascal: 1e5,
-  sg_to_ppg: 8.345404265,
-  bbl_to_m3: 0.158987294928,
-  // https://en.wikipedia.org/wiki/Unit_of_volume
-  USGal_to_m3: 0.003785411784,
-  // https://en.wikipedia.org/wiki/Unit_of_volume
-  kelvin_to_degrees: 273.15,
-  tonnes_to_pascal: 9806.65,
-  therm_exp_coeff: 1242e-8,
-  psi_to_pascal: 6894.757293168361,
-  // ((0.45359237 kg x 9.80665 m/s²)/lbf) / (0.0254 m/in)²
-  ft3_to_m3: 0.028316846592,
-  // https://en.wikipedia.org/wiki/Unit_of_volume
-  ft3_to_in3: 1728,
-  // https://en.wikipedia.org/wiki/Cubic_inch
-  day_to_second: 60 * 60 * 24,
-  m3_per_m_to_ft3_per_ft: 10.763910416709722,
-  // https://www.wolframalpha.com/input?i=cubic+meter+per+meter++to+feet+cubic+per+foot&assumption=%7B%22F%22%2C+%22UnitsConversion2%22%2C+%22fromValue%22%7D+-%3E%220.100000000000000000%22
-  in3_per_ft_to_m3_per_m: 537633333333e-16,
-  // 1 / m3_per_m_to_ft3_per_ft / ft3_to_in3 = 0.000053763333333333334  https://www.wolframalpha.com/input?i=cubic+meter+per+meter++to+feet+cubic+per+foot&assumption=%7B%22F%22%2C+%22UnitsConversion2%22%2C+%22fromValue%22%7D+-%3E%220.100000000000000000%22
-  /* OW-24122 Flow rate conversion MSm³/d
-    `Mega Standard Cubic Metre per day` (`MSm3/d`) <-> `meters cubed per second` (`m3/s`)
-        1 `MSm3/d`
-          = `1 * 625/54` `m3/s` (https://www.wolframalpha.com/input?i=Mega+Standard+Cubic+Metre+per+day)
-          = `1 / (86400 * 1e-6)` `m3/s` (OW-24122)
-          = `11.5740740741`
-    We can represent this as `625 / 54`  or `1_000_000 / 86400`
-  */
-  MSm3d_to_m3s: 625 / 54
-});
-const KNOWN_CONVERSIONS = Object.freeze({
-  // LENGTH
-  "m|mm": (val) => val * 1e3,
-  "m|cm": (val) => val * 100,
-  "m|km": (val) => val / 1e3,
-  "m|ft": (val) => val / C.ft_to_m,
-  "m|in": (val) => val / C.inch_to_m,
-  "m|microM": (val) => val * 1e6,
-  "mm|m": (val) => val / 1e3,
-  "cm|m": (val) => val / 100,
-  "km|m": (val) => val * 1e3,
-  "ft|m": (val) => val * C.ft_to_m,
-  "in|m": (val) => val * C.inch_to_m,
-  "microM|m": (val) => val / 1e6,
-  // AREA
-  "m2|mm2": (val) => val * 1e6,
-  "m2|cm2": (val) => val * 1e4,
-  "m2|km2": (val) => val / 1e6,
-  "m2|in2": (val) => val * 1550.0031,
-  "m2|ft2": (val) => val * 10.76391,
-  "m2|mile2": (val) => val * 3861022e-13,
-  "mm2|m2": (val) => val / 1e6,
-  "cm2|m2": (val) => val / 1e4,
-  "km2|m2": (val) => val * 1e6,
-  "in2|m2": (val) => val / 1550.0031,
-  "ft2|m2": (val) => val / 10.76391,
-  "mile2|m2": (val) => val / 3861022e-13,
-  // VOLUME
-  "m3|bbl": (val) => val / C.bbl_to_m3,
-  "m3|ft3": (val) => val / C.ft3_to_m3,
-  "m3|l": (val) => val * 1e3,
-  "m3|Mm3": (val) => val / 1e6,
-  "m3|USGal": (val) => val / C.USGal_to_m3,
-  "bbl|m3": (val) => val * C.bbl_to_m3,
-  "ft3|m3": (val) => val * C.ft3_to_m3,
-  "Mm3|m3": (val) => val * 1e6,
-  "l|m3": (val) => val / 1e3,
-  "USGal|m3": (val) => val * C.USGal_to_m3,
-  "m3|Sm3": (val) => val * 1,
-  "m3|STB": (val) => val * 6.289512957422142,
-  // 42089843750 / 6692067261 = 6.289512957422142, // https://www.wolframalpha.com/input?i=stb
-  "Sm3|m3": (val) => val * 1,
-  "STB|m3": (val) => val * 0.1589948230919721,
-  //6692067261 / 42089843750 = 0.15899482309197216, // https://www.wolframalpha.com/input?i=stb
-  "m3|MMSCF": (val) => val * 1e6 / C.ft3_to_m3,
-  "m3|MSm3": (val) => val * 1e-6,
-  "m3|SCF": (val) => val / C.ft3_to_m3,
-  "MMSCF|m3": (val) => val * 1e-6 * C.ft3_to_m3,
-  "MSm3|m3": (val) => val * 1e6,
-  "SCF|m3": (val) => val * C.ft3_to_m3,
-  // DENSITY
-  "kg/m3|sg": (val) => val * 1e-3,
-  "kg/m3|g/cm3": (val) => val * 1e-3,
-  "kg/m3|lbm/ft3": (val) => val / 16.01846337,
-  "kg/m3|lb/ft3": (val) => val / 16.01846337,
-  "kg/m3|ppg": (val) => val * 0.008345404265,
-  "sg|kg/m3": (val) => val * 1e3,
-  "g/cm3|kg/m3": (val) => val * 1e3,
-  "lbm/ft3|kg/m3": (val) => val * 16.01846337,
-  "lb/ft3|kg/m3": (val) => val * 16.01846337,
-  "ppg|kg/m3": (val) => val / 0.008345404265,
-  "sg|kPa/m": (val) => val * 9.81,
-  "kPa/m|sg": (val) => val / 9.81,
-  // GAS DENSITY
-  "Gkg/m3|Gsg": (val) => val / 1.225,
-  "Gkg/m3|Glbm/ft3": (val) => val / 16.0176516725,
-  "Gkg/m3|Gppg": (val) => val / 119.8659491193,
-  "Gsg|Gkg/m3": (val) => val * 1.225,
-  "Glbm/ft3|Gkg/m3": (val) => val * 16.0176516725,
-  "Gppg|Gkg/m3": (val) => val * 119.8659491193,
-  // WLTUBULARS
-  "ppf|kg/m": (val) => val * 0.45359237 / 0.3048,
-  "kg/m|ppf": (val) => val * 1 / (0.45359237 / 0.3048),
-  "kg/m|lbf/ft": (val) => val / 0.67196897675131,
-  "lbf/ft|kg/m": (val) => val * 0.67196897675131,
-  // PRESSURE / STRESS
-  "Pa|psi": (val) => val / C.psi_to_pascal,
-  "psi|Pa": (val) => val * C.psi_to_pascal,
-  "Pa|bar": (val) => val * 1e-5,
-  "Pa|kPa": (val) => val * 1e-3,
-  "Pa|MPa": (val) => val * 1e-6,
-  "Pa|GPa": (val) => val * 1e-9,
-  "bar|Pa": (val) => val * 1e5,
-  "kPa|Pa": (val) => val * 1e3,
-  "MPa|Pa": (val) => val * 1e6,
-  "GPa|Pa": (val) => val * 1e9,
-  "psi|ksi": (val) => val / 1e3,
-  "ksi|psi": (val) => val * 1e3,
-  "psi|lbf/100ft2": (val) => val * 14400,
-  // psi = lbf/in²,  1 ft² = 144 in²  https://en.wikipedia.org/wiki/Square_foot
-  "lbf/100ft2|psi": (val) => val / 14400,
-  // FLUID COMPRESSIBILITY
-  "1/psi|1/Pa": (val) => val / C.psi_to_pascal,
-  "1/bar|1/Pa": (val) => val * 1e-5,
-  "1/kPa|1/Pa": (val) => val * 1e-3,
-  "1/MPa|1/Pa": (val) => val * 1e-6,
-  "1/GPa|1/Pa": (val) => val * 1e-9,
-  "1/Pa|1/psi": (val) => val * C.psi_to_pascal,
-  "1/Pa|1/bar": (val) => val * 1e5,
-  "1/Pa|1/kPa": (val) => val * 1e3,
-  "1/Pa|1/MPa": (val) => val * 1e6,
-  "1/Pa|1/GPa": (val) => val * 1e9,
-  // TEMPERATURE
-  "C|F": (val) => val * 1.8 + 32,
-  "F|C": (val) => (val - 32) * 5 / 9,
-  "K|C": (val) => val - C.kelvin_to_degrees,
-  "C|K": (val) => val + C.kelvin_to_degrees,
-  // TEMPERATURE GRADIENT
-  "C/100m|F/100ft": (val) => val * 1.8 * C.ft_to_m,
-  "F/100ft|C/100m": (val) => val * 5 / 9 / C.ft_to_m,
-  "C/100m|C/m": (val) => val / 100,
-  "C/m|C/100m": (val) => val * 100,
-  "C/100m|F/ft": (val) => val * 1.8 / 100 * C.ft_to_m,
-  "F/ft|C/100m": (val) => val * 5 / 9 * 100 / C.ft_to_m,
-  "C/100m|K/m": (val) => val / 100,
-  "K/m|C/100m": (val) => val * 100,
-  "K/100m|C/100m": (val) => val,
-  "C/100m|K/100m": (val) => val,
-  // PRESSURE PER TEMPERATURE
-  "Pa/C|Bar/C": (val) => val * 1e-5,
-  "Pa/C|psi/F": (val) => val / 1.8 / C.psi_to_pascal,
-  "Pa/C|psi/C": (val) => val / C.psi_to_pascal,
-  // https://en.wikipedia.org/wiki/Pound_per_square_inch
-  "Bar/C|Pa/C": (val) => val * 1e5,
-  "psi/F|Pa/C": (val) => val * 1.8 * C.psi_to_pascal,
-  "psi/C|Pa/C": (val) => val * C.psi_to_pascal,
-  //  ((0.45359237 kg x 9.80665 m/s²)/lbf) / (0.0254 m/in)²
-  "psi/F|psi/C": (val) => val * 1.8,
-  "psi/C|psi/F": (val) => val / 1.8,
-  // WEIGHTf
-  "kg|kgf": (val) => val,
-  "kg|lbf": (val) => val * C.kg_to_lbf,
-  "kg|t": (val) => val / 1e3,
-  "kg|tonnes": (val) => val / 1e3,
-  "kg|mt": (val) => val / 1e3,
-  /*
-  1 kip = 1000 lbf - https://en.wikipedia.org/wiki/Kip_(unit)
-  */
-  "kg|kip": (val) => val * C.kg_to_lbf * 1e-3,
-  "kgf|kg": (val) => val,
-  "lbf|kg": (val) => val * C.lbf_to_kg,
-  "t|kg": (val) => val * 1e3,
-  "tonnes|kg": (val) => val * 1e3,
-  "mt|kg": (val) => val * 1e3,
-  "kip|kg": (val) => val * 1e3 * C.lbf_to_kg,
-  "tonnes|lbf": (val) => val * 1e3 * C.kg_to_lbf,
-  "lbf|tonnes": (val) => val * C.lbf_to_kg / 1e3,
-  "t|lbf": (val) => val * 1e3 * C.kg_to_lbf,
-  "lbf|t": (val) => val * C.lbf_to_kg / 1e3,
-  "mt|lbf": (val) => val * 1e3 * C.kg_to_lbf,
-  "lbf|mt": (val) => val / (1e3 * C.kg_to_lbf),
-  "kgf|lbf": (val) => val * C.kg_to_lbf,
-  "lbf|kgf": (val) => val * C.lbf_to_kg,
-  "kg|g": (val) => val * 1e3,
-  "g|kg": (val) => val / 1e3,
-  "kgf|t": (val) => val / 1e3,
-  "t|kgf": (val) => val * 1e3,
-  "kgf|tonnes": (val) => val / 1e3,
-  "tonnes|kgf": (val) => val * 1e3,
-  // MASS PER LENGTH
-  "kg/m|lb/ft": (val) => val * 1.4881639435695537,
-  "lb/ft|kg/m": (val) => val * 0.6719689751395069,
-  "kg|N": (val) => val * C.g * 100,
-  "N|kg": (val) => val / (C.g * 100),
-  // DISTANCE PER TIME
-  "m/s|km/h": (val) => val * 3.6,
-  "km/h|m/s": (val) => val / 3.6,
-  "m/s|ft/s": (val) => val / C.ft_to_m,
-  "m/s|ft/min": (val) => val * 60 / C.ft_to_m,
-  "m/s|ft/h": (val) => val * 3600 / C.ft_to_m,
-  "m/s|m/min": (val) => val * 60,
-  "m/s|m/h": (val) => val * 3600,
-  "ft/s|m/s": (val) => val * C.ft_to_m,
-  "ft/min|m/s": (val) => val * C.ft_to_m / 60,
-  "ft/h|m/s": (val) => val * C.ft_to_m / 3600,
-  "m/min|m/s": (val) => val / 60,
-  "m/h|m/s": (val) => val / 3600,
-  "m/s|mph": (val) => val * 2.2369362920544,
-  "mph|m/s": (val) => val / 2.2369362920544,
-  "ft/h|ft/d": (val) => val * 24,
-  "ft/d|ft/h": (val) => val / 24,
-  "ft/h|m/h": (val) => val * C.ft_to_m,
-  "m/h|ft/h": (val) => val / C.ft_to_m,
-  "ft/d|m/h": (val) => val * C.ft_to_m / 24,
-  "m/h|ft/d": (val) => val * 24 / C.ft_to_m,
-  "ft/d|m/d": (val) => val * C.ft_to_m,
-  "m/d|ft/d": (val) => val / C.ft_to_m,
-  "m/h|m/d": (val) => val * 24,
-  "m/d|m/h": (val) => val / 24,
-  // LINEAR CAPACITY
-  "l/m|bbl/ft": (val) => val * 0.0019171343228277056,
-  "bbl/ft|l/m": (val) => val / 0.0019171343228277056,
-  // FLOW RATES
-  "m3/s|ft3/s": (val) => val / C.ft3_to_m3,
-  "m3/s|lpm": (val) => val * 6e4,
-  "m3/s|bpm": (val) => val * 377.388646,
-  "m3/s|m3/min": (val) => val * 60,
-  "m3/s|m3/d": (val) => val * C.day_to_second,
-  "m3/s|bbl/d": (val) => val * 543439.6505653338,
-  "m3/s|ft3/d": (val) => val * C.day_to_second / C.ft3_to_m3,
-  "m3/s|gpm": (val) => val * 25e11 / 157725491,
-  // https://www.wolframalpha.com/input?i=m3%2Fs+
-  "m3/s|MMSCFD": (val) => val / 0.32774128,
-  "m3/s|STB/d": (val) => val * 1346875e8 / 247854343,
-  "m3/s|Sm3/d": (val) => val * C.day_to_second,
-  "m3/s|Sm3/min": (val) => val * 60,
-  "Sm3/min|m3/s": (val) => val / 60,
-  "m3/s|MSm3/d": (val) => val / C.MSm3d_to_m3s,
-  "m3/s|SCF/d": (val) => val * 3.0511872047366146e6,
-  "ft3/s|m3/s": (val) => val * C.ft3_to_m3,
-  "lpm|m3/s": (val) => val / 6e4,
-  "lps|lpm": (val) => val * 60,
-  "lpm|lps": (val) => val / 60,
-  "bpm|m3/s": (val) => val / 377.388646,
-  "m3/d|m3/s": (val) => val / C.day_to_second,
-  "m3/min|m3/s": (val) => val / 60,
-  "bbl/d|m3/s": (val) => val / C.day_to_second * C.bbl_to_m3,
-  "ft3/d|m3/s": (val) => val / C.day_to_second * C.ft3_to_m3,
-  "ft3/d|m3/d": (val) => val * C.ft3_to_m3,
-  "m3/d|ft3/d": (val) => val / C.ft3_to_m3,
-  "m3/d|ft3/s": (val) => val / C.ft3_to_m3 / C.day_to_second,
-  "gpm|m3/s": (val) => val * 157725491 / 25e11,
-  // https://www.wolframalpha.com/input?i=m3%2Fs+
-  "MMSCFD|m3/s": (val) => val * 0.32774128,
-  "Mm3/d|m3/d": (val) => val * 1e6,
-  "m3/d|Mm3/d": (val) => val * 1e-6,
-  /*
-   exact formula is 247854343 / 134687500000000 = 0.0000018402178598607888  - https://www.wolframalpha.com/input?i=STB%2Fd
-   STB has a lot of intermediate conversions, so to avoid delta during conversions trip we have to store 2 more digits
-  */
-  "STB/d|m3/s": (val) => val * 184021785986e-17,
-  "Sm3/d|m3/d": (val) => val,
-  // At a pressure of 101.325 kPa (760 Torr) and DIN 1343: a temperature of 273.15 K (0°C/32°F) | NOTE: Thomas suggested that we leep those conversions 1to1,
-  "m3/d|Sm3/d": (val) => val,
-  // because the calculated rate is the rate at standard conditions
-  "Sm3/d|m3/s": (val) => val / C.day_to_second,
-  "MSm3/d|Sm3/d": (val) => val * 1e6,
-  "Sm3/d|MSm3/d": (val) => val * 1e-6,
-  "MSm3/d|m3/s": (val) => val * C.MSm3d_to_m3s,
-  "SCF/d|m3/s": (val) => val * 32774128e-14,
-  // TURBULENT SKIN
-  "1/m3/d|1/MMSCFD": (val) => val * 28316.85,
-  "1/MMSCFD|1/m3/d": (val) => val / 28316.85,
-  "s/m3|1/m3/d": (val) => val / 86400,
-  "1/m3/d|s/m3": (val) => val * 86400,
-  // MASS FLOW RATES
-  "kg/s|lbm/s": (val) => val * 2.20462262,
-  "lbm/s|kg/s": (val) => val / 2.20462262,
-  "kg/s|tonnes/h": (val) => val * 3.6,
-  "tonnes/h|kg/s": (val) => val / 3.6,
-  "kg/s|tons/h": (val) => val * 3.9683207193277967,
-  "tons/h|kg/s": (val) => val * 0.2519957611111111,
-  "lbm/s|tonnes/h": (val) => val * 1.632932532,
-  "tonnes/h|lbm/s": (val) => val * 0.612395172735771,
-  "lbm/s|tons/h": (val) => val * 1.8,
-  "tons/h|lbm/s": (val) => val / 1.8,
-  "tonnes/h|tons/h": (val) => val * 1.1023113109243878,
-  "tons/h|tonnes/h": (val) => val * 0.90718474,
-  // PERMEABILITY
-  "mD|m2": (val) => val * 9869233e-19,
-  // https://en.wikipedia.org/wiki/Darcy_(unit)
-  "m2|mD": (val) => val / 9869233e-19,
-  // GRADIENTS - Force / INTERFACIAL TENSION:
-  "N/m|lbf/ft": (val) => val * 0.22480894387096 * C.ft_to_m,
-  "lbf/ft|N/m": (val) => val / 0.22480894387096 / C.ft_to_m,
-  "dyn/cm|mN/m": (val) => val,
-  "mN/m|dyn/cm": (val) => val,
-  "dyn/cm|N/m": (val) => val * 1e-3,
-  "N/m|dyn/cm": (val) => val * 1e3,
-  "mN/m|N/m": (val) => val * 1e-3,
-  "N/m|mN/m": (val) => val * 1e3,
-  // TORQUE
-  "Nm|ftlbf": (val) => val * 0.737562058700684,
-  "Nm|kNm": (val) => val / 1e3,
-  "kNm|Nm": (val) => val * 1e3,
-  "ftlbf|Nm": (val) => val / 0.737562058700684,
-  // FORCE
-  "N|kN": (val) => val * 1e-3,
-  "N|kgf": (val) => val * 2e4 / 196133,
-  // https://www.wolframalpha.com/input?i=newtons
-  "N|lbf": (val) => val * 2e12 / 8896443230521,
-  // https://www.wolframalpha.com/input?i=newtons
-  "kN|lbf": (val) => val * 1e3 * 2e12 / 8896443230521,
-  "N|tonneForce": (val) => val * 20 / 196133,
-  // https://www.wolframalpha.com/input?i=tonneForce
-  "kN|N": (val) => val / 1e-3,
-  "kgf|N": (val) => val * 196133 / 2e4,
-  // https://www.wolframalpha.com/input?i=kgf
-  "lbf|N": (val) => val * 8896443230521 / 2e12,
-  // https://www.wolframalpha.com/input?i=newtons
-  "lbf|kN": (val) => val * 8896443230521 / (2e12 * 1e3),
-  "lbf|tonneForce": (val) => val * 45359237 / 1e11,
-  // https://www.wolframalpha.com/input?i=tonneForce
-  "klbf|tonneForce": (val) => val * 45359237 / (1e11 * 1e-3),
-  "tonneForce|N": (val) => val * 196133 / 20,
-  // https://www.wolframalpha.com/input?i=tonneForce
-  "tonneForce|lbf": (val) => val * 1e11 / 45359237,
-  //https://www.wolframalpha.com/input?i=tonneForce
-  "tonneForce|klbf": (val) => val * 1e11 / (45359237 * 1e3),
-  // https://www.wolframalpha.com/input?i=tonneForce
-  "klbf|lbf": (val) => val * 1e3,
-  "lbf|klbf": (val) => val / 1e3,
-  // DURATION
-  "s|min": (val) => val / 60,
-  "s|h": (val) => val / 3600,
-  "s|d": (val) => val / (24 * 3600),
-  "min|s": (val) => val * 60,
-  "h|s": (val) => val * 3600,
-  "d|s": (val) => val * 24 * 3600,
-  "year|d": (val) => val * 365.25,
-  "d|year": (val) => val / 365.25,
-  "year|month": (val) => val * 12,
-  "month|year": (val) => val / 12,
-  "month|d": (val) => val * 30.4375,
-  "d|month": (val) => val / 30.4375,
-  // TIME/STAND DURATION
-  "s/stand|min/stand": (val) => val / 60,
-  "s/stand|h/stand": (val) => val / 3600,
-  "s/stand|d/stand": (val) => val / 86400,
-  "min/stand|s/stand": (val) => val * 60,
-  "h/stand|s/stand": (val) => val * 3600,
-  "d/stand|s/stand": (val) => val * 86400,
-  "min/stand|h/stand": (val) => val / 60,
-  "min/stand|d/stand": (val) => val / 1440,
-  "h/stand|min/stand": (val) => val * 60,
-  "h/stand|d/stand": (val) => val / 24,
-  "d/stand|min/stand": (val) => val * 1440,
-  "d/stand|h/stand": (val) => val * 24,
-  // PERCENTAGE / FRACTIONS
-  "%|fr": (val) => val * 0.01,
-  "fr|%": (val) => val / 0.01,
-  // DEGREES
-  "deg|rad": (val) => val * Math.PI / 180,
-  "rad|deg": (val) => val * 180 / Math.PI,
-  // POWER
-  "W|hp": (val) => val / 745.699872,
-  "hp|W": (val) => val * 745.699872,
-  "W|kW": (val) => val / 1e3,
-  "W|MW": (val) => val / 1e6,
-  "kW|W": (val) => val * 1e3,
-  "MW|W": (val) => val * 1e6,
-  "W|BTU/h": (val) => val * 3.4121416351331,
-  "BTU/h|W": (val) => val / 3.4121416351331,
-  "hhp|hp": (val) => val,
-  // hydraulic horsepower is just horsepower
-  "hp|hhp": (val) => val,
-  // NAVIGATION
-  "\xB0N|\xB0S": (val) => val,
-  "\xB0S|\xB0N": (val) => val,
-  "\xB0W|\xB0E": (val) => val,
-  "\xB0E|\xB0W": (val) => val,
-  // Specific Heat Capacity
-  "BTU/(Kg*K)|BTU/(lbm*degF)": (val) => val / 4186.798188,
-  "BTU/(lbm*degF)|J/(kg*degC)": (val) => val * 4186.798188,
-  "BTU/(lbm*degF)|BTU/(Kg*K)": (val) => val * 4186.798188,
-  "J/(kg*degK)|J/(kg*degC)": (val) => val,
-  "J/(kg*degC)|BTU/(lbm*degF)": (val) => val / 4186.798188,
-  "J/(kg*degC)|J/(kg*degK)": (val) => val,
-  "J/(kg*degC)|J/(s*m*degK)": (val) => val,
-  // Thermal conductivity
-  "BTU/(h*ft*degF)|W/(mK)": (val) => val * 1.7295772056,
-  "BTU/(h*ft*degF)|J/(s*m*degK)": (val) => val * 1.7295772056,
-  "W/(mK)|BTU/(h*ft*degF)": (val) => val / 1.7295772056,
-  "W/(mK)|J/(s*m*degK)": (val) => val,
-  "W/(m*degK)|J/(s*m*degK)": (val) => val,
-  "W/(m*degK)|BTU/(h*ft*degF)": (val) => val / 1.7295772056,
-  "J/(s*m*degK)|BTU/(h*ft*degF)": (val) => val / 1.7295772056,
-  "J/(s*m*degK)|W/(m*degK)": (val) => val,
-  "J/(s*m*degK)|W/(mK)": (val) => val,
-  "J/(s*m*degK)|J/(kg*degC)": (val) => val,
-  // THERMAL EXPANSION
-  "E-06/degF|E-06/degC": (val) => val * 1.8,
-  "E-06/degC|E-06/degF": (val) => val / 1.8,
-  "E-06/degC|1/K": (val) => val / 1e6,
-  "1/K|E-06/degC": (val) => val * 1e6,
-  // FREQUENCY
-  "rpm|Hz": (val) => val / 60,
-  "Hz|rpm": (val) => val * 60,
-  // Confidence interval
-  "CI|Sigma": (val) => get_k_from_conf_int(val),
-  "Sigma|CI": (val) => get_conf_int_from_k(val),
-  // Mole weight:
-  "g/mol|kg/mol": (val) => val / 1e3,
-  "kg/mol|g/mol": (val) => val * 1e3,
-  "lbf/mol|kg/mol": (val) => val / C.kg_to_lbf,
-  "kg/mol|lbf/mol": (val) => val * C.kg_to_lbf,
-  // Acceleration:
-  "m/s2|ft/s2": (val) => val / C.ft_to_m,
-  "ft/s2|m/s2": (val) => val * C.ft_to_m,
-  // Viscosity:
-  "Pa*s|P": (val) => val * 10,
-  "P|Pa*s": (val) => val / 10,
-  "mPa*s|Pa*s": (val) => val / 1e3,
-  "Pa*s|mPa*s": (val) => val * 1e3,
-  "cP|Pa*s": (val) => val * 1e-3,
-  "Pa*s|cP": (val) => val / 1e-3,
-  // GRADIENTS - Pressure:
-  "Pa/m|bar/m": (val) => val * 1e-5,
-  "bar/m|Pa/m": (val) => val * 1e5,
-  "Pa/m|kPa/m": (val) => val / 1e3,
-  "kPa/m|Pa/m": (val) => val * 1e3,
-  "Pa/m|bar/100m": (val) => val * 1e-3,
-  "bar/100m|Pa/m": (val) => val * 1e3,
-  "bar/m|bar/100m": (val) => val * 100,
-  "bar/100m|bar/m": (val) => val / 100,
-  "psi/ft|Pa/m": (val) => val * C.psi_to_pascal / C.ft_to_m,
-  "Pa/m|psi/ft": (val) => val / C.psi_to_pascal * C.ft_to_m,
-  "psi/100ft|Pa/m": (val) => val * 68.9475729 / C.ft_to_m,
-  "Pa/m|psi/100ft": (val) => val / 68.9475729 * C.ft_to_m,
-  // Gradients - Angles:
-  "deg/30m|deg/100ft": (val) => val * (100 * C.ft_to_m / 30),
-  "deg/100ft|deg/30m": (val) => val / (100 * C.ft_to_m / 30),
-  "deg/30m|deg/m": (val) => val / 30,
-  "deg/m|deg/30m": (val) => val * 30,
-  "deg/100ft|deg/ft": (val) => val / 100,
-  "deg/ft|deg/100ft": (val) => val * 100,
-  "deg/100ft|deg/m": (val) => val / (100 * C.ft_to_m),
-  "deg/m|deg/100ft": (val) => val * (100 * C.ft_to_m),
-  "deg/ft|deg/m": (val) => val / C.ft_to_m,
-  "deg/m|deg/ft": (val) => val * C.ft_to_m,
-  "deg/m|rad/m": (val) => val * Math.PI / 180,
-  "rad/m|deg/m": (val) => val * 180 / Math.PI,
-  "rad/ft|deg/m": (val) => val * 180 / Math.PI / C.ft_to_m,
-  "deg/m|rad/ft": (val) => val * Math.PI / 180 * C.ft_to_m,
-  "deg/10m|deg/100ft": (val) => val * (10 * C.ft_to_m),
-  "deg/100ft|deg/10m": (val) => val / (10 * C.ft_to_m),
-  "deg/10m|deg/m": (val) => val / 10,
-  "deg/m|deg/10m": (val) => val * 10,
-  "deg/30m|deg/10m": (val) => val / 3,
-  "deg/10m|deg/30m": (val) => val * 3,
-  "deg/10m|rad/m": (val) => val * Math.PI / 180 / 10,
-  "rad/m|deg/10m": (val) => val * 180 / Math.PI * 10,
-  // intensity
-  "W/m2|hhp/in2": (val) => val * (1 / 745.699872 / 1550.0031),
-  "W/m2|hhp/ft2": (val) => val * (1 / 745.699872 / 10.76391),
-  "hhp/in2|W/m2": (val) => val / (1 / 745.699872 / 1550.0031),
-  "hhp/ft2|W/m2": (val) => val / (1 / 745.699872 / 10.76391),
-  // Gas Oil Ratio:
-  "SCF/STB|Sm3/Sm3": (val) => val * 0.178099173553719,
-  // 431 / 2420 = 0.17809917355371901 -  https://www.wolframalpha.com/input?i=Standard+Cubic+Feet+per+Stock+Tank+Barrel
-  "Sm3/Sm3|SCF/STB": (val) => val * 5.614849187935035,
-  // 2420 / 431 = 5.614849187935035
-  // Inflow Productivity Index
-  "Sm3/d/bar|m3/s/bar": (val) => val / 86400,
-  "STB/d/psi|m3/s/bar": (val) => val / 37468.77736,
-  "m3/s/bar|Sm3/d/bar": (val) => val * 86400,
-  "m3/s/bar|STB/d/psi": (val) => val * 37468.77736,
-  "E-10/psi|E-09/bar": (val) => val * 1.450377378,
-  "E-10/psi|E-14/pa": (val) => val * 1.450377378,
-  "E-14/pa|E-10/psi": (val) => val / 1.450377378,
-  "E-09/bar|E-10/psi": (val) => val / 1.450377378,
-  "E-14/pa|1/Pa": (val) => val / Math.pow(10, 14),
-  "E-09/bar|1/bar": (val) => val / Math.pow(10, 9),
-  "E-10/psi|1/psi": (val) => val / Math.pow(10, 10),
-  "1/Pa|E-14/pa": (val) => val * Math.pow(10, 14),
-  "1/bar|E-09/bar": (val) => val * Math.pow(10, 9),
-  "1/psi|E-10/psi": (val) => val * Math.pow(10, 10),
-  // volumeGradient
-  "m3/m|cm3/m": (val) => val * 10 ** 6,
-  "m3/m|mm3/m": (val) => val * 10 ** 9,
-  "m3/m|ft3/ft": (val) => val * C.m3_per_m_to_ft3_per_ft,
-  "m3/m|in3/ft": (val) => val * C.m3_per_m_to_ft3_per_ft * C.ft3_to_in3,
-  "cm3/m|m3/m": (val) => val * 1e-6,
-  "cm3/m|mm3/m": (val) => val * 1e3,
-  "cm3/m|ft3/ft": (val) => val * C.m3_per_m_to_ft3_per_ft * 1e-6,
-  "cm3/m|in3/ft": (val) => val * C.m3_per_m_to_ft3_per_ft * 1e-6 * C.ft3_to_in3,
-  "mm3/m|m3/m": (val) => val * 1e-9,
-  "mm3/m|cm3/m": (val) => val * 1e-3,
-  "mm3/m|ft3/ft": (val) => val * C.m3_per_m_to_ft3_per_ft * 1e-9,
-  "mm3/m|in3/ft": (val) => val * C.m3_per_m_to_ft3_per_ft * 1e-9 * C.ft3_to_in3,
-  "ft3/ft|m3/m": (val) => val * 0.09290304,
-  "ft3/ft|cm3/m": (val) => val * 92903.04,
-  "ft3/ft|mm3/m": (val) => val * 92903040,
-  "ft3/ft|in3/ft": (val) => val * 1728,
-  "in3/ft|m3/m": (val) => val * C.in3_per_ft_to_m3_per_m,
-  "in3/ft|cm3/m": (val) => val * C.in3_per_ft_to_m3_per_m * 1e6,
-  "in3/ft|mm3/m": (val) => val * C.in3_per_ft_to_m3_per_m * 1e9,
-  "in3/ft|ft3/ft": (val) => val / C.ft3_to_in3,
-  // shearStress
-  "Pa|lbf/100ft2": (val) => val * 2.088543423315013,
-  // (100 * 185806080000) / 8896443230521 = 2.088543423315013 - https://www.wolframalpha.com/input?i=Pa+unit
-  "lbf/100ft2|Pa": (val) => val * 0.4788025898033584,
-  // 8896443230521 / (185806080000 * 100) = 0.47880258980335844, // https://www.wolframalpha.com/input?i=Pa+unit
-  // GIS Location Systems
-  "usft|m": (val) => val * 0.30480060960121924,
-  "lk|m": (val) => val * 0.201168,
-  "ftCla|m": (val) => val * 0.3047972651151,
-  "lkCla|m": (val) => val * 0.2011057269733667,
-  "ftGC|m": (val) => val * 0.30479971018150875,
-  "ydInd|m": (val) => val * 0.9143985307444408,
-  "ftSe|m": (val) => val * (12 / 39.370147),
-  "ydSe|m": (val) => val * 0.9143991154275526,
-  "chSe|m": (val) => val * 20.11676512155263,
-  "chSe(T)|m": (val) => val * 20.116756,
-  "m|usft": (val) => val / 0.30480060960121924,
-  "m|lk": (val) => val / 0.201168,
-  "m|ftCla": (val) => val / 0.3047972651151,
-  "m|lkCla": (val) => val / 0.2011057269733667,
-  "m|ftGC": (val) => val / 0.30479971018150875,
-  "m|ydInd": (val) => val / 0.9143985307444408,
-  "m|ftSe": (val) => val / (12 / 39.370147),
-  "m|ydSe": (val) => val / 0.9143991154275526,
-  "m|chSe": (val) => val / 20.11676512155263,
-  "m|chSe(T)": (val) => val / 20.116756,
-  // Mixing Requirements
-  "m3/t|L/100kg": (val) => val * 100,
-  "L/100kg|m3/t": (val) => val * 0.01,
-  //entalphy
-  "kJ/kg|J/kg": (val) => val * 1e3,
-  "J/kg|kJ/kg": (val) => val / 1e3,
-  "BTU/lbm|J/kg": (val) => val * 2326,
-  "J/kg|BTU/lbm": (val) => val / 2326,
-  // sensor accelerometer
-  "g|m/s2": (val) => val * 9.81,
-  "m/s2|g": (val) => val / 9.81,
-  // sensor magnetometer
-  "Gs|nT": (val) => val * 1e5,
-  "nT|Gs": (val) => val / 1e5
-});
-const DEPRECATED_UNITS = Object.freeze({
-  "N-m": "Nm",
-  "ft-lbf": "ftlbf",
-  "BTU/hr": "BTU/h",
-  "BTU/(htf*degF)": "BTU/(h*ft*degF)",
-  "BTU/(hft*degF)": "BTU/(h*ft*degF)"
-});
-const UNIT_ALIASES = Object.freeze({
-  "lbs/ft": "lb/ft",
-  "lbm/ft": "lb/ft",
-  // pound-mass per feet
-  ftUS: "usft"
-  // US feet, GIS interpretation
-});
-const INTERMEDIATE_CONVERSIONS = Object.freeze({
-  // LENGTH
-  mm: "m",
-  cm: "m",
-  km: "m",
-  ft: "m",
-  in: "m",
-  microM: "m",
-  // WEIGHT
-  lbf: "kg",
-  t: "kg",
-  tonnes: "kg",
-  mt: "kg",
-  kip: "kg",
-  // POWER
-  kW: "W",
-  MW: "W",
-  hp: "W",
-  hhp: "hp",
-  // AREA
-  mm2: "m2",
-  cm2: "m2",
-  km2: "m2",
-  in2: "m2",
-  ft2: "m2",
-  mile2: "m2",
-  // VOLUME
-  bbl: "m3",
-  ft3: "m3",
-  Mm3: "m3",
-  l: "m3",
-  USGal: "m3",
-  Sm3: "m3",
-  STB: "m3",
-  MMSCF: "m3",
-  MSm3: "m3",
-  SCF: "m3",
-  // FORCE
-  kN: "N",
-  kgf: "N",
-  tonneForce: "N",
-  klbf: "lbf",
-  // PRESSURE
-  psi: "Pa",
-  bar: "Pa",
-  kPa: "Pa",
-  MPa: "Pa",
-  ksi: "psi",
-  "lbf/100ft2": "psi",
-  // Pressure gradients:
-  "psi/100ft": "Pa/m",
-  "psi/ft": "Pa/m",
-  "bar/100m": "Pa/m",
-  "bar/m": "Pa/m",
-  "Pa/m": "kPa/m",
-  // DENSITY
-  sg: "kg/m3",
-  "g/cm3": "kg/m3",
-  "lbm/ft3": "kg/m3",
-  "lb/ft3": "kg/m3",
-  ppg: "kg/m3",
-  "kPa/m": "sg",
-  // GAS DENSITY
-  Gsg: "Gkg/m3",
-  Gppg: "Gkg/m3",
-  "Glbm/ft3": "Gkg/m3",
-  // FLUID COMPRESSIBILITY
-  "1/psi": "1/Pa",
-  "1/bar": "1/Pa",
-  "1/kPa": "1/Pa",
-  "1/MPa": "1/Pa",
-  "1/GPa": "1/Pa",
-  // DISTANCE PER TIME
-  "ft/s": "m/s",
-  "ft/min": "m/s",
-  "ft/h": "m/s",
-  "m/min": "m/s",
-  "m/h": "m/s",
-  mph: "m/s",
-  // FLOW RATE
-  "ft3/s": "m3/s",
-  lpm: "m3/s",
-  lps: "lpm",
-  bpm: "m3/s",
-  "m3/d": "m3/s",
-  "bbl/d": "m3/s",
-  "ft3/d": "m3/s",
-  "STB/d": "m3/s",
-  "Sm3/d": "m3/s",
-  "Sm3/min": "m3/s",
-  gpm: "m3/s",
-  MMSCFD: "m3/s",
-  "Mm3/d": "m3/d",
-  "m3/min": "m3/s",
-  "MSm3/d": "m3/s",
-  "lbf/ft": "N/m",
-  // DURATION
-  min: "s",
-  h: "s",
-  d: "s",
-  month: "d",
-  year: "d",
-  //Specific Heat Capacity
-  "J/(kg*degK)": "J/(kg*degC)",
-  "BTU/(lbm*degF)": "J/(kg*degC)",
-  "BTU/(Kg*K)": "J/(kg*degC)",
-  //Thermal conductivity
-  "BTU/(h*ft*degF)": "J/(s*m*degK)",
-  "W/(m*degK)": "J/(s*m*degK)",
-  "W/(mK)": "J/(s*m*degK)",
-  // Temperature:
-  K: "C",
-  // Temp grad:
-  "C/m": "C/100m",
-  "F/ft": "C/100m",
-  "K/m": "C/100m",
-  "F/100ft": "C/100m",
-  "K/100m": "C/100m",
-  // Pressure Per Temperature
-  "Bar/C": "Pa/C",
-  // Turbulent skin
-  "s/m3": "1/m3/d",
-  "1/MMSCFD": "1/m3/d",
-  // Visosity:
-  P: "Pa*s",
-  "mPa*s": "Pa*s",
-  cP: "Pa*s",
-  // Intensity:
-  "hhp/in2": "W/m2",
-  "hhp/ft2": "W/m2",
-  // Inflow Productivity Index:
-  "Sm3/d/bar": "m3/s/bar",
-  "STB/d/psi": "m3/s/bar",
-  // Angle gradients:
-  "deg/100ft": "deg/m",
-  "deg/30m": "deg/m",
-  "deg/10m": "deg/m",
-  "deg/ft": "deg/m",
-  "rad/ft": "deg/m",
-  // Mole weight:
-  "lbf/mol": "kg/mol",
-  "g/mol": "kg/mol",
-  // Thermal expansion
-  "1/K": "E-06/degC",
-  "E-09/bar": "E-10/psi",
-  "E-14/pa": "E-10/psi",
-  "1/Pa": "E-14/pa",
-  // TORQUE
-  kNm: "Nm",
-  ftlbf: "Nm",
-  // GIS Location Systems
-  lk: "m",
-  ftCla: "m",
-  lkCla: "m",
-  ftSe: "m",
-  ydSe: "m",
-  chSe: "m",
-  "chSe(T)": "m",
-  ftGC: "m",
-  ydInd: "m",
-  //Entalphy
-  "BTU/lbm": "J/kg"
-});
-const KNOWN_UNITS = Object.freeze(
-  Array.from(new Set(Object.values(ALT_UNITS).flat()))
-);
-const SPECIAL_NUMBERS = [NaN, -Infinity, Infinity];
-const SPECIAL_NUMBERS_STRING = SPECIAL_NUMBERS.map(
-  (number) => number.toString()
-);
-const QUANTITIES_DESCRIPTION = {
-  density: "Density",
-  length: "Length",
-  duration: "Duration",
-  temperature: "Temperature",
-  tempgrad: "Temperature Gradient",
-  volume: "Volume",
-  weight: "Weight",
-  angles: "Angles",
-  depth: "Depth",
-  distance: "Distances",
-  height: "Height",
-  diameters: "Diameters",
-  doglegSeverity: "Dogleg severity",
-  fluidCompressibility: "Fluid Compressibility",
-  force: "Force",
-  gasVolume: "Gas volume",
-  oilVolume: "Oil volume",
-  moleWeight: "Mole weight",
-  linearCapacity: "Linear Capacity",
-  stress: "Stress",
-  thermalConductivity: "Thermal conductivity",
-  specificHeatCapacity: "Specific heat capacity",
-  thermalExpansionCoefficient: "Thermal expansion coefficient",
-  youngsModulus: "Youngs Modulus",
-  torque: "Torque",
-  areaOther: "Area - Other",
-  areaTubular: "Area - Tubular",
-  pumpRate: "Pump Rate",
-  pressure: "Pressure",
-  blowoutFlowRate: "Flowrate (blowout)",
-  percentage: "Percentage",
-  frequency: "Frequency",
-  torqueGradient: "Torque gradient",
-  pressureGradient: "Pressure gradient",
-  flowrate: "Volumetric flow rate",
-  massFlowRate: "Mass flow rate",
-  angleGradient: "Angle gradient",
-  weightGradient: "Weight gradient",
-  forceGradient: "Force gradient",
-  interfacialTension: "Interfacial tension",
-  acceleration: "Acceleration",
-  viscosity: "Viscosity",
-  power: "Power",
-  intensity: "Power intensity",
-  gasliftFlowRate: "Flowrate (Gas lift)",
-  productionFlowRate: "Flowrate (production)",
-  productionFlowRateOil: "Flowrate for Oil (production)",
-  productionFlowRateGas: "Flowrate for Gas (production)",
-  injectionFlowRate: "Flowrate (injection)",
-  blowoutOilFlowRate: "Flowrate for Oil (blowout)",
-  blowoutGasFlowRate: "Flowrate for Gas (blowout)",
-  gor: "Gas Oil Ratio",
-  rotationalSpeed: "Rotational Speed",
-  densityGas: "Density for gas",
-  inflowProductivityIndex: "Inflow productivity index",
-  latitude: "Latitude",
-  longitude: "Longitude",
-  permeability: "Permeability",
-  sdstats: "Standard deviation",
-  roughness: "Material Roughness",
-  wltubulars: "Tubular weight",
-  speed: "Velocity",
-  inverseStandSpeed: "Inverse Stand velocity",
-  rop: "Rate of Penetration (ROP)",
-  densityOil: "Density for oil",
-  densityOilGas: "Density for oil/gas",
-  kickToleranceVolume: "Volume for kick tolerance",
-  densitySolid: "Density for solid",
-  massPerLength: "Mass Per Length",
-  durationShort: "Duration (TempSim short)",
-  durationLong: "Duration (TempSim long)",
-  wearFactor: "Wear factor",
-  turbulentSkin: "Turbulent skin",
-  pressurePerTemperature: "Pressure per temperature",
-  location: "Location coordinates length",
-  mixingRequirements: "Ratio between water and cement",
-  Entalphy: "Entalphy",
-  shearStress: "Shear Stress, force parallel to surface",
-  volumeGradient: "Rate of Volume change per unit",
-  deg: "Degree, a unit of angular measurement",
-  dls: "Dogleg Severity, measure of wellbore curvature changes per unit length",
-  wgrad: "Weight Gradient, change in weight per unit length",
-  entalphy: "Entalphy, total heat content of a system",
-  pressurechange: "Change in pressure over time or between two points",
-  rpm: "Rotations per minute, a measure of the frequency of rotation, specifying the number of full rotations completed in one minute around a fixed axis",
-  sensorAccelerometer: "Strength of gravitational acceleration",
-  sensorMagnetometer: "Strength of magnetic forces at a position"
-};
-const UNITS_DESCRIPTION = {
-  in: "Inches",
-  mm: "Milimeters",
-  cm: "Centimeters",
-  m: "Meters",
-  km: "Kilometers",
-  ft: "Feets",
-  usft: "US Feets",
-  in2: "Square inches",
-  cm2: "Square centimeters",
-  m2: "Square meters",
-  kg: "Kilograms",
-  tonnes: "Tonnes",
-  mt: "Metric tonnes",
-  kip: "Kip",
-  bbl: "Barrels",
-  Mm3: "Mega cubic meters",
-  MMSCF: "Million Standard Cubic Feet",
-  lbm: "Pound mass",
-  "kg/mol": "Kilograms per mole",
-  "lbf/mol": "Pounds per mole",
-  sg: "Specific gravity",
-  ppg: "Pounds per gallon",
-  "kg/m3": "Kilogram per cubic meters",
-  "lbm/ft3": "Pounds per cubic foot",
-  s: "Seconds",
-  min: "Minutes",
-  h: "Hours",
-  d: "Days",
-  month: "Months",
-  year: "Years",
-  "bbl/ft": "Barrels per foot",
-  lpm: "Litres per minute",
-  bpm: "Barrels per minute",
-  "m3/min": "Cubic meters per minute",
-  "m3/s": "Cubic meters per second",
-  MMSCFD: "Million Standard Cubic Feet per day",
-  "1/MMSCFD": "Inverse Million Standard Cubic Feet per day",
-  bar: "Bar",
-  Pa: "Pascals",
-  kPa: "Kilopascals",
-  MPa: "Megapascals",
-  kPsi: "Kilo pounds per square inch",
-  "kPa/m": "Kilopascals per meter",
-  "psi/ft": "Psi per foot",
-  "bar/100m": "Bars per 100m",
-  "psi/100ft": "Psi per 100ft",
-  "kPa/100m": "Kilopascals per 100m",
-  C: "Degrees Celsius",
-  F: "Degrees Fahrenheit",
-  K: "Kelvins",
-  "C/100m": "Degrees Celsius per 100m",
-  "F/100ft": "Degrees Fahrenheit per 100m",
-  "K/100m": "Kelvins per 100m",
-  "lbf/ft": "Pound force / foot",
-  "Pa/C": "Pascal per celsius",
-  "Bar/C": "Bar per celsius",
-  "psi/F": "Psi per fahrenheit",
-  "psi/C": "Psi per celsius",
-  N: "Newtons",
-  kN: "Kilo Newtons",
-  "N/m": "Newtons per meter",
-  "daN/m": "Decanewtons per meter",
-  lbf: "Pound force",
-  kgf: "Kilogram force",
-  rad: "Radians",
-  "BTU/lbm": "British Thermal Units per pound",
-  ppf: "Pound per foot",
-  "kg/m": "Kilograms per meter",
-  "E-06/degC": "Micro per degree Celsius",
-  "E-06/degF": "Micro per degree Fahrenheit",
-  km2: "Square kilometers",
-  ft2: "Square feet",
-  mm2: "Square millimeters",
-  mile2: "Square miles",
-  ft3: "Cubic feet",
-  "g/cm3": "Grams per cubic centimeter",
-  Sm3: "Standard cubic meter",
-  "ft3/s": "Cubic feet per second",
-  "ft3/d": "Cubic feet per day",
-  "m3/d": "Cubic meter per day",
-  "1/m3/d": "Inverse Cubic meter per day",
-  "s/m3": "Seconds per cubic meters",
-  "bbl/d": "Barrels per day",
-  tonneForce: "Tonne force",
-  USGal: "US gallon",
-  "g/mol": "Grams per mol",
-  Nm: "Newton meter",
-  kNm: "Kilo Newton meter",
-  ftlbf: "Foot pound",
-  "J/(kg*degC)": "Joules per kilogram degree Celsius",
-  "J/(kg*degK)": "Joules per kilogram degree Kelwin",
-  "BTU/(lbm*degF)": "British Thermal Unit per pound Fahrenheit",
-  "BTU/(h*ft*degF)": "British Thermal Units per hour feet degree Fahrenheit",
-  l: "Litres",
-  "l/m": "Litres per meter",
-  "kJ/kg": "Kilo joules per kilogram",
-  "J/kg": "Joules per kilogram",
-  deg: "Degrees",
-  "W/(mK)": "Watts per milli Kelvin",
-  psi: "Pounds per square inch",
-  "1/bar": "1/bar",
-  "1/psi": "1/psi",
-  "deg/100ft": "Degrees per 100ft",
-  "deg/10m": "Degrees per 10m",
-  "deg/30m": "Degrees per 30m",
-  "%": "Percent",
-  Hz: "Hertz",
-  "1/s": "Inverse second",
-  rpm: "Revolutions per minute",
-  "Pa/m": "Pascal per meter",
-  "bar/m": "Bar per meter",
-  gpm: "Gallons per minute",
-  "kg/s": "Kilograms per second",
-  "lbm/s": "Pound mass per second",
-  "tonnes/h": "Tonnes per hour",
-  "tons/h": "Tons per hour",
-  "deg/m": "Degrees per meter",
-  "deg/ft": "Degrees per foot",
-  "rad/m": "Radians per meter",
-  "rad/ft": "Radians per foot",
-  "dyn/cm": "Dyn per centimeter",
-  "mN/m": "Millinewtons per meter",
-  "1/kPa": "1/kPa",
-  m3: "Cubic meters",
-  "m/s": "Meters per second",
-  "ft/s": "Feet per second",
-  "m/min": "Meters per minute",
-  "ft/min": "Feet per min",
-  "m/h": "Meters per hour",
-  "ft/h": "Feet per hour",
-  mph: "Miles per hour",
-  "km/h": "Kilometers per hour",
-  "m/s2": "Meters per second squared",
-  "ft/s2": "Feet per second squared",
-  "Pa*s": "Pascal seconds",
-  P: "Poise (dyne second per square centimeter)",
-  "mPa*s": "Millipascal seconds",
-  cP: "Centi Poise",
-  W: "Watts",
-  hhp: "Hydraulic horsepower",
-  hp: "Horsepower",
-  kW: "Kilowatts",
-  MW: "Megawatts",
-  "BTU/h": "British Thermal Units per hour",
-  "hhp/in2": "Hydraulic horsepower per square inch",
-  "hhp/ft2": "Hydraulic horsepower per square feet",
-  "Mm3/d": "Mega cubic meters per day",
-  "STB/d": "Stock Tank Barrel per day",
-  "Sm3/d": "Standard cubic meters per day",
-  "Sm3/min": "Standard cubic meters per minute",
-  "MSm3/d": "Mega standard cubic meters per day",
-  "SCF/STB": "Standard Cubic Feet per Stock Tank Barrel",
-  "Sm3/Sm3": "Standard cubic meters per Standard cubic meter",
-  "SCF/d": "Standard cubic feet per day",
-  STB: "Stock Tank Barrel",
-  SCF: "Standard Cubic Feet",
-  Gsg: "Gas - specific gravity",
-  Gppg: "Gas - pounds per gallon",
-  "Gkg/m3": "Gas - kilogram per cubic meters",
-  "Glbm/ft3": "Gas - pounds per cubic foot",
-  MSm3: "Mega standard cubic meters",
-  "m3/s/bar": "Cubic per second per bar",
-  "Sm3/d/bar": "Standard cubic per day per bar",
-  "STB/d/psi": "Standard barrels per day per psi",
-  klbf: "kilopound force",
-  "1/Pa": "1/Pascal",
-  "1/MPa": "1/MPa",
-  ksi: "Kilopound per square inch",
-  "lbf/100ft2": "Pounds per 100 square foot",
-  "lb/ft3": "lb/ft3",
-  "\xB0N": "\xB0N (latitude)",
-  "\xB0S": "\xB0S (latitude)",
-  "\xB0W": "\xB0W (longitude)",
-  "\xB0E": "\xB0E (longitude)",
-  fr: "Fraction",
-  mD: "Millidarcy",
-  Sigma: "Sigma",
-  CI: "Confidence Interval",
-  "J/(s*m*degK)": "Joules per second meter Kelvin",
-  "C/m": "Degrees Celsius per meter",
-  "F/ft": "Degrees Fahrenheit per meter",
-  "K/m": "Kelvin per meter",
-  microM: "Micro meter",
-  "W/m2": "Watt per square meter",
-  "1/K": "Inverse Kelvin",
-  "lb/ft": "Pound Per Feet",
-  "E-09/bar": "Nano per bar",
-  "E-10/psi": "10\u207B\xB9\u2070 per psi",
-  "E-14/pa": "10\u207B\xB9\u2074 per pascal",
-  lk: "Link",
-  ftCla: "Clark`s foot",
-  lkCla: "Clark`s link",
-  ftSe: "British foot (Sears 1922)",
-  ydSe: "British yard (Sears 1922)",
-  chSe: "British chain (Sears 1922)",
-  "chSe(T)": "British chain (Sears 1922 Truncated)",
-  ftGC: "Gold Coast foot",
-  ydInd: "Indian yard",
-  "d/stand": "Day per stand",
-  "h/stand": "Hour per stand",
-  "min/stand": "Minute per stand",
-  "s/stand": "Second per stand",
-  "m3/t": "Cubic meter per ton",
-  "L/100kg": "Liter per 100kg",
-  GPa: "Gigapascals, unit of pressure",
-  "cm3/m": "Cubic cm per meter",
-  "in3/ft": "Cubic inches per foot",
-  "ft3/ft": "Cubic feet per foot",
-  "m3/m": "Cubic meters per meter",
-  "mm3/m": "Cubic millimeters per meter",
-  "1/GPa": "Inverse gigapascal",
-  lps: "Liters per second",
-  nT: "nanoTesla",
-  Gs: "Gauss",
-  g: "g force"
-};
-
-var ucs2length = {};
-
-var hasRequiredUcs2length;
-
-function requireUcs2length () {
-	if (hasRequiredUcs2length) return ucs2length;
-	hasRequiredUcs2length = 1;
-	Object.defineProperty(ucs2length, "__esModule", { value: true });
-	function ucs2length$1(str) {
-	  const len = str.length;
-	  let length = 0;
-	  let pos = 0;
-	  let value;
-	  while (pos < len) {
-	    length++;
-	    value = str.charCodeAt(pos++);
-	    if (value >= 55296 && value <= 56319 && pos < len) {
-	      value = str.charCodeAt(pos);
-	      if ((value & 64512) === 56320)
-	        pos++;
-	    }
-	  }
-	  return length;
-	}
-	ucs2length.default = ucs2length$1;
-	ucs2length$1.code = 'require("ajv/dist/runtime/ucs2length").default';
-	return ucs2length;
-}
-
-const numberSchemaValidator = validate15;
-function validate15(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
-  let vErrors = null;
-  let errors = 0;
-  if (!(typeof data == "number" && isFinite(data))) {
-    const err0 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "number" }, message: "must be number" };
-    if (vErrors === null) {
-      vErrors = [err0];
-    } else {
-      vErrors.push(err0);
-    }
-    errors++;
-  }
-  if (errors > 0) {
-    const emErrs0 = [];
-    for (const err1 of vErrors) {
-      if (err1.keyword !== "errorMessage" && !err1.emUsed && (err1.instancePath === instancePath || err1.instancePath.indexOf(instancePath) === 0 && err1.instancePath[instancePath.length] === "/") && err1.schemaPath.indexOf("#") === 0 && err1.schemaPath["#".length] === "/") {
-        emErrs0.push(err1);
-        err1.emUsed = true;
-      }
-    }
-    if (emErrs0.length) {
-      const err2 = { instancePath, schemaPath: "#/errorMessage", keyword: "errorMessage", params: { errors: emErrs0 }, message: "Must be a numerical value" };
-      if (vErrors === null) {
-        vErrors = [err2];
-      } else {
-        vErrors.push(err2);
-      }
-      errors++;
-    }
-    const emErrs1 = [];
-    for (const err3 of vErrors) {
-      if (!err3.emUsed) {
-        emErrs1.push(err3);
-      }
-    }
-    vErrors = emErrs1;
-    errors = emErrs1.length;
-  }
-  validate15.errors = vErrors;
-  return errors === 0;
-}
-/*@__PURE__*/ requireUcs2length().default;
-
-const transformErrors = (errors) => {
-  return errors?.map(({ message }) => message);
-};
-
-const SEPARATOR = "|";
-const UNIT_RE = /^(-?[0-9., /]*?(?:e[-+]?[0-9]+)?)([^0-9-., /].*)?$/;
-const EXP_NOTATION_RE = /^[-+]?[0-9]*\.?[0-9]+(?:\/[0-9]*\.?[0-9]+)?(?:[eE][-+]?[0-9]+)?$/;
-function showAltUnitsList(quantityKey) {
-  return ALT_UNITS[quantityKey];
-}
-function getUnitsForQuantity(quantity) {
-  return showAltUnitsList(quantity);
-}
-function getQuantities() {
-  return Object.keys(ALT_UNITS);
-}
-function label(unitKey) {
-  return LABELS[unitKey];
-}
-function unitFromKey(quantity) {
-  return UNIT_FROM_KEY[quantity];
-}
-function unitFromQuantity(quantity) {
-  return unitFromKey(quantity);
-}
-function getAltUnitsListByQuantity(quantity) {
-  const quantityUnitList = showAltUnitsList(quantity);
-  return quantityUnitList ? quantityUnitList.map((unit) => ({ unit, label: label(unit) })) : void 0;
-}
-function checkAndCleanDecimalComma(val) {
-  const RegExForMultiDots = /\.{2,}/;
-  const RegexFindComma = /,/;
-  if (typeof val === "string") {
-    while (RegExForMultiDots.test(val) || RegexFindComma.test(val)) {
-      val = val.replace(RegExForMultiDots, ".");
-      val = val.replace(RegexFindComma, ".");
-    }
-  }
-  return val;
-}
-function to(value, fromUnit, toUnit) {
-  value = checkAndCleanDecimalComma(value);
-  value = normalizeScientific(value);
-  if (toUnit === "undefined") {
-    console.warn('Inconsistent "to unit" - debug call to "Units.to()"');
-  }
-  if (fromUnit === "undefined") {
-    fromUnit = toUnit;
-    console.warn('Inconsistent "from unit" - debug call to "Units.to()"');
-  }
-  if (fromUnit === toUnit) {
-    return toNum(value);
-  }
-  if (value === Infinity || value === "Infinity") {
-    return Infinity;
-  }
-  if (value === -Infinity || value === "-Infinity") {
-    return -Infinity;
-  }
-  if (isNonNumerical(value) && value !== "") {
-    return NaN;
-  }
-  const conv = KNOWN_CONVERSIONS[fromUnit + "|" + toUnit];
-  if (conv) {
-    return conv(toNum(value));
-  }
-  if (DEPRECATED_UNITS[fromUnit]) {
-    console.warn(
-      `Unit '${fromUnit}' is deprecated - use '${DEPRECATED_UNITS[fromUnit]}' instead.`
-    );
-    return to(value, DEPRECATED_UNITS[fromUnit], toUnit);
-  }
-  if (DEPRECATED_UNITS[toUnit]) {
-    console.warn(
-      `Unit '${toUnit}' is deprecated - use '${DEPRECATED_UNITS[toUnit]}' instead.`
-    );
-    return to(value, fromUnit, DEPRECATED_UNITS[toUnit]);
-  }
-  if (UNIT_ALIASES[toUnit]) {
-    return to(value, fromUnit, UNIT_ALIASES[toUnit]);
-  }
-  if (UNIT_ALIASES[fromUnit]) {
-    return to(value, UNIT_ALIASES[fromUnit], toUnit);
-  }
-  const int_from = INTERMEDIATE_CONVERSIONS[fromUnit];
-  if (int_from) {
-    const int_val = to(value, fromUnit, int_from);
-    return to(int_val, int_from, toUnit);
-  } else {
-    const int_to = INTERMEDIATE_CONVERSIONS[toUnit];
-    if (toUnit && int_to && int_to !== toUnit) {
-      const int_val = to(value, fromUnit, int_to);
-      return to(int_val, int_to, toUnit);
-    }
-  }
-  console.error("no conversions found", value, fromUnit, "->", toUnit);
-  throw new Error(
-    "No conversions found: " + value + " " + fromUnit + " -> " + toUnit
-  );
-}
-function split(numWithUnit) {
-  let m;
-  let vu = numWithUnit !== void 0 && numWithUnit !== null ? String(numWithUnit) : "";
-  if (charCount(SEPARATOR, vu) > 1) {
-    m = vu.split(SEPARATOR);
-    vu = m.slice(0, -1).join("") + SEPARATOR + m.slice(-1);
-  }
-  if (vu.indexOf(SEPARATOR) >= 0) {
-    m = vu.split(SEPARATOR);
-  } else if (SPECIAL_NUMBERS_STRING.includes(vu)) {
-    m = [vu, ""];
-  } else {
-    m = cleanNumStr(vu).match(UNIT_RE);
-    if (m) {
-      m = m.slice(1);
-    }
-  }
-  if (!m) m = ["0", ""];
-  if (m[1] == null) m[1] = "";
-  return [m[0], m[1]];
-}
-function getValue(numWithUnit) {
-  return split(numWithUnit)[0];
-}
-function getUnit(numWithUnit) {
-  return split(numWithUnit)[1];
-}
-function unum(numWithUnit, toUnit, fromUnit) {
-  if (numWithUnit == null || numWithUnit === "") {
-    return 0;
-  }
-  if (typeof numWithUnit === "string" && numWithUnit.startsWith("NaN") || typeof numWithUnit === "number" && isNaN(numWithUnit)) {
-    return NaN;
-  }
-  const normInput = normalizeScientific(numWithUnit);
-  const cleanStr = cleanNumStr(normInput).replaceAll("+", "");
-  const m = split(cleanStr);
-  if (!m) {
-    if (toUnit && fromUnit) return unum(numWithUnit + fromUnit, toUnit);
-    else throw new Error("unum: invalid number: " + numWithUnit);
-  }
-  if (m[0] == null) m[0] = "0";
-  if (m[1]) fromUnit = m[1];
-  if (!fromUnit && toUnit !== fromUnit) {
-    throw new Error(
-      `unum: unable to figure out unit: ${numWithUnit} fromUnit ${fromUnit}`
-    );
-  }
-  if (toUnit === fromUnit) {
-    const v = m[0] ? toNum(m[0]) : 0;
-    if (v === Infinity || v === "Infinity") {
-      return Infinity;
-    }
-    if (v === -Infinity || v === "-Infinity") {
-      return -Infinity;
-    }
-    if (typeof v === "string" && EXP_NOTATION_RE.test(v)) {
-      return parseFloat(v);
-    }
-    if (!isNumeric(v) && v !== Infinity && v !== -Infinity) {
-      throw new Error("unum: invalid number: " + v + ", " + typeof v);
-    }
-    return cleanNum(v);
-  }
-  return to(m[0], fromUnit, toUnit);
-}
-function isValueWithUnit(value) {
-  if (!value) {
-    return false;
-  }
-  const splittedValue = String(value).split(SEPARATOR);
-  return splittedValue.length === 2 && KNOWN_UNITS.includes(splittedValue[1]);
-}
-function convertAndGetValue(numWithUnit, toUnit, fromUnit) {
-  return unum(numWithUnit, toUnit, fromUnit);
-}
-function convertAndGetValueStrict(value, toUnit, fromUnit) {
-  if (value === "" || value === null) {
-    return value;
-  }
-  if (typeof value === "string" && isValueWithUnit(value) && getValue(value) === "") {
-    return "";
-  }
-  const isString = typeof value === "string";
-  const result = convertAndGetValue(value, toUnit, fromUnit);
-  return isString ? String(toString(result)) : result;
-}
-function toBase(value, quantity) {
-  const to_unit = unitFromKey(quantity);
-  const m = split((value || "").toString());
-  return unum(value, to_unit, m[1] || to_unit);
-}
-function convertTable(toUnitRow, table, defaultUnitRow, removeFinalUnitsRow = false) {
-  if (!table || !table.length || !table[0].length) return table;
-  if (!toUnitRow) toUnitRow = table[0];
-  if (!defaultUnitRow) defaultUnitRow = toUnitRow;
-  const firstCell = table[0][0];
-  const splittedFirstCell = firstCell && split(`${firstCell}`);
-  const unitNum = splittedFirstCell && splittedFirstCell[0] && isNaN(splittedFirstCell[1]);
-  const tableHasUnits = !unitNum && isNaN(table[0][0]);
-  let ix = tableHasUnits ? 1 : 0;
-  const fromunitrow = tableHasUnits ? table[0] : defaultUnitRow;
-  const newTable = [toUnitRow];
-  for (; ix < table.length; ix++) {
-    const cols = Array(toUnitRow.length);
-    const coli = table[ix];
-    for (let uix = 0; uix < cols.length; uix++) {
-      cols[uix] = toUnitRow[uix] && coli[uix] ? unum(coli[uix], toUnitRow[uix], fromunitrow[uix]) : coli[uix];
-    }
-    newTable.push(cols);
-  }
-  if (removeFinalUnitsRow) newTable.shift();
-  return newTable;
-}
-function roundNumberWithLabel(value, n = 2) {
-  return displayNumber(round(value, n), { withUnit: true });
-}
-function withUnit(value, unit, defaultVal = "") {
-  if (value === null || value === "" || value === void 0) {
-    value = defaultVal;
-  }
-  if (unit === null) {
-    return String(value);
-  }
-  let [v, u] = String(value).includes(SEPARATOR) ? split(String(value)) : [value, unit];
-  if (!u) {
-    u = unit;
-  }
-  return [v, u].join(SEPARATOR);
-}
-function unumWithUnit(numWithUnit, toUnit, fromUnit) {
-  return withUnit(unum(numWithUnit, toUnit, fromUnit), toUnit);
-}
-function convertSamePrecision(numWithUnit, toUnit, digits) {
-  const validNumWithUnit = String(numWithUnit);
-  const m = split(validNumWithUnit);
-  const convertedNumber = !m[1] || m[1] == toUnit ? Number(m[0]) : to(m[0], String(m[1]), toUnit);
-  let prettyNumber = "0";
-  let targetDigits = digits;
-  if (convertedNumber !== 0) {
-    if (!targetDigits) {
-      if (m[1] === toUnit) {
-        return validNumWithUnit;
-      }
-      const regx = String(m[0]).match(/^[-+.,0]*(\d*)[.,]?(\d*)/);
-      if (regx) {
-        targetDigits = Math.max(3, regx[1].length + regx[2].length);
-      } else {
-        targetDigits = 3;
-      }
-    }
-    const lim = Math.pow(10, --targetDigits);
-    const absNum = Math.abs(convertedNumber);
-    if (absNum >= 1e5 * lim || absNum * 1e4 * (1 + lim) < lim) {
-      prettyNumber = convertedNumber.toExponential(targetDigits);
-    } else if (absNum >= lim) {
-      prettyNumber = convertedNumber.toFixed();
-    } else {
-      const digs = Math.floor(Math.log10(absNum));
-      prettyNumber = convertedNumber.toFixed(targetDigits - digs);
-      let j = prettyNumber.length;
-      if (prettyNumber[--j] == "0") {
-        while (prettyNumber[--j] == "0") ;
-        prettyNumber = prettyNumber.slice(
-          0,
-          j + (prettyNumber[j] == "." ? 0 : 1)
-        );
-      }
-    }
-  }
-  return withUnit(prettyNumber, toUnit);
-}
-function altUnitsList(value, quantity) {
-  let v = value;
-  if (!getUnit(value)) {
-    v = withUnit(value, unitFromQuantity(quantity) ?? "");
-  }
-  const altUnits = ALT_UNITS[quantity] ?? [];
-  return altUnits.map((unit) => [
-    ...split(convertSamePrecision(v, unit)),
-    label(unit)
-  ]);
-}
-function validateAndClean(previousValue, nextText) {
-  const unit = split(previousValue)[1];
-  const stripAllExceptNumeric = /[^0-9.,-Ee]/g;
-  const stripE = /^([^(e|E)]*[eE])|[eE]/g;
-  const stripInvalidLeading = /^[E|e]*|[E|e]*$/g;
-  const replaceComma = /,/g;
-  const stripDot = /^([^.]*\.)|\./g;
-  const stripDotFollowedByE = /\.(?=e)/g;
-  const stripMinus = /-|[eE]-/g;
-  const cleanedValue = nextText.replace(stripAllExceptNumeric, "").replace(stripE, "$1").replace(stripInvalidLeading, "").replace(replaceComma, ".").replace(stripDot, "$1").replace(stripDotFollowedByE, "").replace(
-    stripMinus,
-    (match, offset) => offset === 0 || match.toLowerCase() === "e-" ? match : ""
-  );
-  return !Number.isFinite(+cleanedValue) ? previousValue : `${cleanedValue}${unit ? "|" : ""}${unit}`;
-}
-function withPrettyUnitLabel(valueWithUnits) {
-  const [val, unit] = split(valueWithUnits);
-  const prettyUnit = LABELS[unit] ?? "";
-  return `${val} ${prettyUnit}`;
-}
-function validateNumber(value) {
-  let val = value;
-  if (typeof value === "string" && isValueWithUnit(value)) {
-    val = getValue(value);
-  }
-  val = checkAndCleanDecimalComma(val);
-  if (isNumeric(val)) {
-    const valid2 = numberSchemaValidator(toNum(val));
-    return { valid: valid2, errors: transformErrors(numberSchemaValidator.errors) };
-  }
-  const valid = numberSchemaValidator(val);
-  return { valid, errors: transformErrors(numberSchemaValidator.errors) };
-}
-
-export { split as $, ALT_UNITS as A, isCloseToOrLessThan as B, isDeepCloseTo as C, DEPRECATED_UNITS as D, isEmptyValueWithUnit as E, isFraction as F, isNonNumerical as G, isNumeric as H, INTERMEDIATE_CONVERSIONS as I, isScientificStringNum as J, KNOWN_CONVERSIONS as K, LABELS as L, isValidNum as M, isValueWithUnit as N, label as O, numFraction as P, QUANTITIES_DESCRIPTION as Q, round as R, roundByMagnitude as S, roundByMagnitudeToFixed as T, UNITS_DESCRIPTION as U, roundByRange as V, roundNumberWithLabel as W, roundToDecimalPrecision as X, roundToFixed as Y, roundToPrecision as Z, showAltUnitsList as _, KNOWN_UNITS as a, stripLeadingZeros as a0, to as a1, toBase as a2, toNum as a3, toString as a4, unitFromKey as a5, unitFromQuantity as a6, unum as a7, unumWithUnit as a8, validateAndClean as a9, validateNumber as aa, withPrettyUnitLabel as ab, withUnit as ac, EXP_NOTATION_RE as ad, SEPARATOR as ae, UNIT_ALIASES as b, UNIT_FROM_KEY as c, allNumbers as d, altUnitsList as e, asFraction as f, charCount as g, checkAndCleanDecimalComma as h, cleanNum as i, cleanNumStr as j, convertAndGetValue as k, convertAndGetValueStrict as l, convertSamePrecision as m, convertTable as n, displayNumber as o, displayNumberToFixed as p, formatNumber as q, fraction as r, getAltUnitsListByQuantity as s, getNumberOfDigitsToShow as t, getQuantities as u, getUnit as v, getUnitsForQuantity as w, getValue as x, isCloseTo as y, isCloseToOrGreaterThan as z };