@oliasoft-open-source/units 4.3.0-beta-2 → 4.3.0-beta-4

package/dist/index.js

@@ -1,2514 +1,2 @@
-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) : 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 = /^-/mg;
-  const matchLeadingZeros = /^(?:0+(?=[1-9])|0+(?=0))/mg;
-  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 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",
-  "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",
-  "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",
-  "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",
-    "MSm3/d",
-    "SCF/d"
-  ],
-  blowoutGasFlowRate: ["MMSCFD", "Sm3/d", "MSm3/d", "SCF/d"],
-  blowoutOilFlowRate: ["Sm3/d", "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",
-    "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"],
-  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", "MSm3/d", "SCF/d"],
-  productionFlowRateOil: ["MMSCFD", "STB/d", "Sm3/d", "MSm3/d", "SCF/d"],
-  productionFlowRateGas: ["MMSCFD", "STB/d", "Sm3/d", "MSm3/d", "SCF/d"],
-  injectionFlowRate: ["lpm", "lps", "bpm", "gpm", "MMSCFD", "STB/d", "Sm3/d", "MSm3/d", "SCF/d"],
-  pumpRate: ["lpm", "lps", "bpm", "m3/s", "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"],
-  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",
-  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"
-});
-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
-});
-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|MSm3/d": (val) => val / 11.59722222222222,
-  "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 * 11.59722222222222,
-  "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,
-  // 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
-});
-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",
-  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: "sdstats",
-  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"
-};
-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",
-  "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",
-  "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"
-};
-
-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;
-}
-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);
-  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 cleanStr = cleanNumStr(numWithUnit).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 { ALT_UNITS, DEPRECATED_UNITS, INTERMEDIATE_CONVERSIONS, KNOWN_CONVERSIONS, KNOWN_UNITS, LABELS, QUANTITIES_DESCRIPTION, UNITS_DESCRIPTION, UNIT_ALIASES, UNIT_FROM_KEY, allNumbers, altUnitsList, asFraction, charCount, checkAndCleanDecimalComma, cleanNum, cleanNumStr, convertAndGetValue, convertAndGetValueStrict, convertSamePrecision, convertTable, displayNumber, displayNumberToFixed, formatNumber, fraction, getAltUnitsListByQuantity, getNumberOfDigitsToShow, getQuantities, getUnit, getUnitsForQuantity, getValue, isCloseTo, isCloseToOrGreaterThan, isCloseToOrLessThan, isDeepCloseTo, isEmptyValueWithUnit, isFraction, isNonNumerical, isNumeric, isScientificStringNum, isValidNum, isValueWithUnit, label, numFraction, round, roundByMagnitude, roundByMagnitudeToFixed, roundByRange, roundNumberWithLabel, roundToDecimalPrecision, roundToFixed, roundToPrecision, showAltUnitsList, split, stripLeadingZeros, to, toBase, toNum, toString, unitFromKey, unitFromQuantity, unum, unumWithUnit, validateAndClean, validateNumber, withPrettyUnitLabel, withUnit };
+export { a3 as ALT_UNITS, a7 as DEPRECATED_UNITS, a9 as INTERMEDIATE_CONVERSIONS, a6 as KNOWN_CONVERSIONS, aa as KNOWN_UNITS, a4 as LABELS, ab as QUANTITIES_DESCRIPTION, ac as UNITS_DESCRIPTION, a8 as UNIT_ALIASES, a5 as UNIT_FROM_KEY, O as allNumbers, i as altUnitsList, W as asFraction, S as charCount, c as checkAndCleanDecimalComma, Z as cleanNum, Y as cleanNumStr, q as convertAndGetValue, x as convertAndGetValueStrict, p as convertSamePrecision, j as convertTable, Q as displayNumber, R as displayNumberToFixed, P as formatNumber, U as fraction, g as getAltUnitsListByQuantity, T as getNumberOfDigitsToShow, b as getQuantities, o as getUnit, a as getUnitsForQuantity, n as getValue, H as isCloseTo, K as isCloseToOrGreaterThan, J as isCloseToOrLessThan, I as isDeepCloseTo, N as isEmptyValueWithUnit, V as isFraction, M as isNonNumerical, L as isNumeric, a1 as isScientificStringNum, a0 as isValidNum, m as isValueWithUnit, l as label, X as numFraction, A as round, E as roundByMagnitude, F as roundByMagnitudeToFixed, G as roundByRange, r as roundNumberWithLabel, D as roundToDecimalPrecision, B as roundToFixed, C as roundToPrecision, s as showAltUnitsList, e as split, a2 as stripLeadingZeros, t as to, h as toBase, _ as toNum, $ as toString, u as unitFromKey, d as unitFromQuantity, f as unum, k as unumWithUnit, v as validateAndClean, z as validateNumber, y as withPrettyUnitLabel, w as withUnit } from './units-eowpZ327.js';
+import 'fraction.js';