@oliasoft-open-source/units 4.7.0 → 5.0.0

package/dist/units2.js

@@ -0,0 +1,3149 @@
+import Fraction from "fraction.js";
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+//#region src/internationalization/internationalization.ts
+const options = { maximumFractionDigits: 20 };
+/**
+* Convert the given number to the browser's default or the given format.
+* Returns the converted number
+*/
+function convertNumberToLocale(number, countryCode) {
+	let numberFormat;
+	try {
+		if (countryCode) numberFormat = new Intl.NumberFormat(countryCode, options);
+		else numberFormat = new Intl.NumberFormat(void 0, options);
+	} catch {
+		numberFormat = new Intl.NumberFormat(void 0, options);
+	}
+	return numberFormat.format(number);
+}
+//#endregion
+//#region src/numbers/numbers.ts
+const parseValue = (value) => {
+	return typeof value === "string" && isValueWithUnit(value) ? getValue(value) : value;
+};
+/**
+* Checks whether a value can be converted to number type by the toNum() function
+*
+* @param value - value to be checked
+* @returns whether number can be converted by toNum() function
+*
+* @example
+* isValidNum('1 1/2') -> true
+* toNum('foobar|m') -> false
+*/
+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("|")) 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;
+};
+/**
+* Checks whether a value is a valid number, in string representation with scientific notation (e.g. '1e3')
+*
+* Note - it's not possible to check whether *number* types are stored in scientific notation (all numbers are stored
+* the same way internally in floating-point formats, so there is no difference between 1000 and 1e3 internally).
+* Whether number types get displayed in scientific notation or not in the console is a browser-specific implementation
+* detail (display formatting) and not something we can check/rely on, so this function is only intended for checking
+* user-input values in string format. See https://stackoverflow.com/a/66005705/942635.
+*
+* @param value - value to be checked
+* @returns whether the value is a valid number in scientific notation
+*
+* @example
+* isValidNum('1e3') -> true
+* toNum(1000) -> false
+* toNum(1e3) -> false (we cannot check scientific notation of number types)
+*/
+const isScientificStringNum = (value) => {
+	if (typeof value === "string") return isValidNum(value) && value.toLowerCase().includes("e");
+	return false;
+};
+/**
+* Converts a numeric value to number type (when possible).
+* - need to know if it's possible first? Call isValidNum()
+* - accepts number types (1.234), stringified numbers ('1.234'), fractions ('1/2'), and unit numbers ('1.234|m')
+* - returns the converted number if possible, otherwise returns the input value or default value when provided
+*
+* @param value - value to be converted to number type
+* @param [fallback] - optional fallback value (returned when not possible to convert)
+* @param [minimum] - optional minimum value
+* @returns valid number after conversion, or fallback, or returns the original input
+*
+* @example
+* toNum('1.2345) -> 1.2345
+* toNum('1.2345|m') -> 1.2345
+*/
+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;
+	}
+};
+/**
+* Convert a number to a string safely, better than String(value)
+*  String(0.0000002) returns '2e-7' which is unwanted if we need to preserve formatting
+*
+* @param value
+* @returns number or string output value
+*/
+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;
+};
+//#endregion
+//#region src/parse/parse-number.ts
+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;
+};
+/**
+* Internal function to parse the value, unit, and type from a generic numeric input
+*
+* Accepts number types (1.234), stringified numbers ('1.234'), and unit numbers ('1.234|m')
+*
+* @param value
+* @returns object with number, unit, and type
+*/
+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);
+	return {
+		number: preserveTrailingZeros && hasTrailingZeros(value) ? cleaned : toNum(cleaned),
+		unit,
+		isString
+	};
+};
+/**
+* Convert a number to a string safely, better than String(value)
+*  String(0.0000002) returns '2e-7' which is unwanted if we need to preserve formatting
+*
+* @param value
+* @param [isScientific] whether to preserve scientific notation
+* @returns number or string output value
+*/
+const safeStringifyNumber = (value, isScientific) => {
+	return isScientific ? String(value) : String(toString(value));
+};
+/**
+* Internal function to unParse a value, unit, and type back to an output value
+*
+* Accepts number types (1.234), stringified numbers ('1.234'), and unit numbers ('1.234|m')
+*
+* @param args
+* @param args.value
+* @param args.unit
+* @param args.isString
+* @param args.isScientific
+* @returns number or string output 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;
+};
+//#endregion
+//#region src/comparison/comparison.ts
+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);
+	return {
+		firstNumber,
+		secondNumber: firstUnit && secondUnit && firstUnit !== secondUnit ? convertAndGetValue(secondNumber, firstUnit, secondUnit) : secondNumber
+	};
+};
+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;
+};
+/**
+* Determines whether two numbers are close in value with a tolerance
+* (mitigates excess JavaScript floating point precision quirks)
+*/
+const isCloseTo = (firstValue, secondValue, options = { relativeDiff: DEFAULT_MAX_RELATIVE_DIFF }) => {
+	const { relativeDiff, absoluteDiff } = options;
+	const toleranceNumber = getToleranceNumber(relativeDiff ?? absoluteDiff);
+	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 diff = Math.abs(firstNumber - secondNumber);
+			return isCloseTo(diff, toleranceNumber, { relativeDiff: "1%" }) || diff < toleranceNumber;
+		} else return 2 * Math.abs((firstNumber - secondNumber) / (firstNumber + secondNumber)) < toleranceNumber;
+	}
+	return false;
+};
+/**
+* Determines whether two numbers are close enough to be equal
+* or checks the firstValue is greater than the secondValue
+*/
+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;
+};
+/**
+* Determines whether two numbers are close enough to be equal
+* or checks the firstValue is less than the secondValue
+*/
+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;
+};
+/**
+* Determines whether two objects or arrays are deeply close equal (all nested child numbers)
+*/
+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((a, i) => isDeepCloseTo(a, 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;
+};
+//#endregion
+//#region src/rounding/rounding.ts
+const DEFAULT_SIGNIFICANT_DIGITS = 4;
+/**
+* Rounds a number to N decimal places.
+*
+* @private (see round() for the public interface)
+* @param value
+* @param [n]
+* @returns rounded number
+*/
+const roundNumber = (value, n = DEFAULT_SIGNIFICANT_DIGITS) => {
+	const factor = 10 ** n;
+	return Math.round(value * factor) / factor;
+};
+/**
+* Rounds a numeric value to N decimal places.
+*
+* - accepts number types (1.234), stringified numbers ('1.234'), and unit numbers ('1.234|m')
+* - returns same type as input
+*
+* @param value - the value to round
+* @param [n] - the number of decimal places to round to
+* @returns rounded value, or input value when unable to round
+*
+* @example
+* round(3.14159265) -> 3.1416
+*/
+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);
+	return unParseNumber({
+		value: !isNumeric(number) || typeof number === "string" && number.endsWith(".") ? value : roundNumber(number, n),
+		unit,
+		isString,
+		isScientific: isScientificStringNum(value)
+	});
+};
+/**
+* Rounds a number to N significant digits.
+*
+* @private (see roundToPrecision() for the public interface)
+* @param value
+* @param [n] number of significant digits
+* @returns rounded number
+*/
+const roundNumberToPrecision = (value, n = DEFAULT_SIGNIFICANT_DIGITS) => {
+	return Number(value.toPrecision(n));
+};
+/**
+* Rounds a number to N significant digits, preserving trailing decimal zeros
+*
+* @private (see roundByMagnitudeToFixed() for the public interface)
+* @param value
+* @param [n] number of significant digits
+* @returns rounded number as string
+*/
+const roundNumberToFixedPrecision = (value, n = DEFAULT_SIGNIFICANT_DIGITS) => {
+	const [integerPart, decimalPart] = toNum(value).toPrecision(n).split(".");
+	if (decimalPart) {
+		const decimalDigits = n - integerPart.length;
+		return `${integerPart}.${decimalPart.padEnd(decimalDigits, "0")}`;
+	} else return integerPart;
+};
+/**
+* Rounds a number to N significant digits, excluding the integer part (only rounds decimal part)
+*
+* @private (see roundToPrecision() for the public interface)
+* @param value
+* @param [n] number of significant digits
+* @returns rounded number
+*/
+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);
+};
+/**
+* Rounds a numeric value to N significant digits.
+*
+* - accepts number types (1.234), stringified numbers ('1.234'), and unit numbers ('1.234|m')
+* - returns same type as input
+* - similar to Number.toPrecision() but safer
+* - does *not* append trailing zeros (unlike `Number(4).toPrecision(4)` -> '4.000')
+*
+* @param value - the value to round
+* @param [n] - the number of significant digits
+* @returns rounded value, or input value when unable to round
+*
+* @example
+* roundToPrecision(0.0000456789) -> 0.00004568
+*/
+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);
+	return unParseNumber({
+		value: !isNumeric(number) || typeof number === "string" && number.endsWith(".") ? value : roundNumberToPrecision(number, n),
+		unit,
+		isString,
+		isScientific: isScientificStringNum(value)
+	});
+};
+/**
+* Rounds a numeric value to N significant digits (only the decimal part)
+*
+* - accepts number types (1.234), stringified numbers ('1.234'), and unit numbers ('1.234|m')
+* - returns same type as input
+* - unlike roundToPrecision(), acts only on the decimal part, not the integer part too
+*
+* @param value - the value to round
+* @param [n]- the number of significant digits
+* @returns rounded value, or input value when unable to round
+*
+* @example
+* roundToPrecision(1234.0000456789) -> 1234.00004568
+*/
+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);
+	return unParseNumber({
+		value: !isNumeric(number) || typeof number === "string" && number.endsWith(".") ? value : roundNumberToDecimalPrecision(number, n),
+		unit,
+		isString,
+		isScientific: isScientificStringNum(value)
+	});
+};
+/**
+* Rounds a number to an appropriate number of digits, based on its size.
+*
+* @private (see roundByMagnitude() for the public interface)
+* @param value
+* @param [n] the number of significant digits
+* @param [toFixed] to fixed digits (i.e. with trailing zeros)
+* @returns rounded number
+*/
+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;
+};
+/**
+* Rounds a numeric value to an appropriate number of digits, based on its size. It rounds to N significant digits,
+* but never rounds the integer part.
+*
+* - accepts number types (1.234), stringified numbers ('1.234'), and unit numbers ('1.234|m')
+* - returns same type as input
+*
+* @param value - the value to round
+* @param [n] - the number of significant digits
+* @returns rounded value, or input value when unable to round
+*
+* @example
+* roundByMagnitude(0.000123456789) -> 0.0001235
+* roundByMagnitude(1.123456789) -> 1.123
+* roundByMagnitude(19999.123456789) -> 19999
+*/
+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);
+	return unParseNumber({
+		value: !isNumeric(number) || typeof number === "string" && number.endsWith(".") ? value : roundNumberByMagnitude(number, n),
+		unit,
+		isString,
+		isScientific: isScientificStringNum(value)
+	});
+};
+/**
+* Rounds a numeric value to an appropriate number of digits, based on its size. It rounds to N significant digits,
+* but never rounds the integer part. Similar to roundByMagnitude, but adds trailing zeros.
+*
+* - accepts number types (1.234), stringified numbers ('1.234'), and unit numbers ('1.234|m')
+* - returns string type (or original value and type when not possible to convert)
+*
+* @param value - the value to round
+* @param [n] - the number of significant digits
+* @returns rounded value as a string, or input value when unable to round
+*
+* @example
+* roundByMagnitudeToFixed(0.000120016789) -> 0.0001200
+*/
+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);
+	return unParseNumber({
+		value: !isNumeric(number) || typeof number === "string" && number.endsWith(".") ? value : roundNumberByMagnitude(number, n, toFixed),
+		unit,
+		isString: true,
+		isScientific: isScientificStringNum(value)
+	});
+};
+/**
+* Rounds a number to an appropriate number of digits, based on its size in relation to a range.
+*
+* @private (see roundByMagnitude() for the public interface)
+* @param value
+* @param min
+* @param max
+* @param [n] the minimum number of significant digits
+* @returns rounded number
+*/
+const roundNumberByRange = (value, min, max, n = DEFAULT_SIGNIFICANT_DIGITS) => {
+	if (isCloseToOrLessThan(max, min)) return value;
+	const range = max - min;
+	return roundNumber(value, Math.max(n, 0 - Math.floor(Math.log10(range))));
+};
+/**
+* Rounds a numeric value to an appropriate number of digits, based on its size within a range of values.
+*
+* - accepts number types (1.234), stringified numbers ('1.234'), and unit numbers ('1.234|m')
+* - returns same type as input
+*
+* @param value - the value to round
+* @param min - the min value in the range
+* @param max - the max value in the range
+* @param [n] - the minimum number of significant digits
+* @returns rounded value, or input value when unable to round
+*
+*/
+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);
+	return unParseNumber({
+		value: !isNumeric(number) || typeof number === "string" && number.endsWith(".") ? value : roundNumberByRange(number, min, max, n),
+		unit,
+		isString,
+		isScientific: isScientificStringNum(value)
+	});
+};
+/**
+* Rounds a numeric value to N fixed decimal digits.
+*
+* - accepts number types (1.234), stringified numbers ('1.234'), and unit numbers ('1.234|m')
+* - returns same type as input
+*
+* @param value - the value to round
+* @param [n] - the number of fixed decimal digits
+* @returns rounded value, or input value when unable to round
+*
+*/
+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);
+	return unParseNumber({
+		value: !isNumeric(number) || typeof number === "string" && number.endsWith(".") ? value : number.toFixed(n),
+		unit,
+		isString,
+		isScientific: isScientificStringNum(value)
+	});
+};
+//#endregion
+//#region src/numbers/display-number.ts
+const DEFAULT_AUTO_SCIENTIFIC_BELOW = 1e-4;
+const DEFAULT_AUTO_SCIENTIFIC_ABOVE = 1e7;
+const superscriptSymbols = {
+	"0": "⁰",
+	"1": "¹",
+	"2": "²",
+	"3": "³",
+	"4": "⁴",
+	"5": "⁵",
+	"6": "⁶",
+	"7": "⁷",
+	"8": "⁸",
+	"9": "⁹",
+	"+": "⁺",
+	"-": "⁻"
+};
+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());
+	return formatDecimal(value, options?.noThousandsSeparator ? "" : nonBreakingSpace ? " " : " ", 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" : "·10";
+	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));
+	return (options?.scientific === "auto" && options?.autoScientificBelow && options?.autoScientificAbove ? abs < options?.autoScientificBelow || abs > options?.autoScientificAbove : options?.scientific) ? formatScientificDisplayNumber(value, options) : formatDecimalDisplayNumber(value, options);
+};
+/**
+* Displays a number with human-friendly formatting (use for non-editable display labels, text)
+*
+* Accepts number types (1.234), stringified numbers ('1.234'), and unit numbers ('1.234|m')
+*
+* @example
+* //returns '1 234.56'
+* displayNumber(1234.56)
+*
+* By default, adds thousands separators. Can be configured to display in scientific notation, and with formatted units.
+*
+* @param value
+* @param options
+* @returns formatted display number
+*/
+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;
+};
+/**
+* Displays a number with human-friendly formatting (use for non-editable display labels, text)
+*
+* Accepts number types (1.234), stringified numbers ('1.234'), and unit numbers ('1.234|m')
+*
+* @example
+* //returns '1 234.5600'
+* displayNumberToFixed('1234.5600')
+*
+* By default, adds thousands separators. Can be configured to display in scientific notation, and with formatted units.
+*
+* @param value
+* @param options
+* @returns formatted display number
+*/
+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 { number, unit } = parseNumber(value, true);
+	const formattedNumber = formatDisplayNumber(number, {
+		...optionsWithDefaults,
+		preserveTrailingZeros: true
+	});
+	const formattedUnit = unit ? LABELS?.[unit] : "";
+	return withUnit && unit ? formattedNumber === "" ? formattedUnit : `${formattedNumber} ${formattedUnit}` : formattedNumber;
+};
+//#endregion
+//#region src/utils.ts
+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);
+/**
+* Checks if input is a string that starts with '|', e.g. '|m' or '|in'
+*
+* @param val - string or number for checking
+* @returns true if input starts with '|', e.g. '|m' or '|in'
+*/
+function isEmptyValueWithUnit(val) {
+	return typeof val === "string" && val.length > 0 && val.startsWith("|");
+}
+const trimWhiteSpace = (value) => value.trim().replace(/\s+/g, " ");
+/**
+* Check if provided argument is number
+* @param v - value for checking
+* @returns true if valid number
+*/
+/**
+* Checks if a value can be parsed as a valid fraction (uses fraction.js)
+*
+* @param value - The value to check.
+* @returns True if the value is a valid fraction, false otherwise.
+*/
+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;
+	return typeof v === "string" ? !isNaN(parseFloat(v)) && (EXP_NOTATION_RE.test(v) || isFinite(v)) : isFinite(v);
+}
+/**
+* Check array values if all are numbers
+* @param arr - array of items
+* @returns true if all array items are numbers
+*/
+function allNumbers(arr) {
+	return !arr.some((val) => typeof val !== "number");
+}
+/**
+* Outputs a human-friendly formatted number for UI display (with thousands separators)
+*
+* @deprecated use displayNumber instead
+* @param number - anything for converting to pretty format
+* @returns string with formatted display number
+*/
+const formatNumber = (number) => displayNumber(number);
+/**
+* Counts all occurence of set character
+* From http://stackoverflow.com/questions/4009756/how-to-count-string-occurrence-in-string
+* @param chr - character that will be counted in string
+* @param str - string in which the character will be counted
+* @returns number of character occurencies
+*/
+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;
+}
+/**
+* Calculates the number of digits to be rounded off, typically for values less than 1
+* E.g. when trying to format 1e-9 by roundNumber(), the output value will only show '0'
+* if just rounded off with 4 digits from roundNumber(val)
+* Then it is more useful to calculate the number of digits to be rounded off, and pass this in,
+* i.e. roundNumber(val, getNumberOfDigitsToShow(val))
+* which will return 0.0000000001.
+* Probably a lot of room for improvement here...
+*
+* @deprecated Use roundByMagnitude or other units package rounding functions instead
+* @param num - number for caculating digits
+* @param maxNumDigits - optional limiter of digits number, by default 20
+* @returns number of digits that will be shown for defined number
+*/
+function getNumberOfDigitsToShow(num, maxNumDigits = 20) {
+	const defaultDigits = Math.min(4, maxNumDigits);
+	let digits = defaultDigits;
+	if (typeof num !== "number") return defaultDigits;
+	const numStr = String(num);
+	if (/-?[0-9.,]*[Ee]-?[0-9]+/.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++) if (numStr[i] !== "0") return Math.min(maxNumDigits, digits + i - 2);
+	return digits;
+}
+/**
+* Convert set fraction to decimal value
+* @param str - fraction to be converted
+* @returns either number in decimal format, Infinity if fraction is divided by 0 or NaN in other cases
+*/
+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;
+}
+/**
+* Converts decimal number to fractional format
+* @param str - value to be converted
+* @returns string with fractional format of set value
+*/
+function asFraction(str) {
+	if (typeof str === "string") str = trimWhiteSpace(str);
+	if (str === "") str = "0";
+	return new Fraction(str).toFraction(true);
+}
+/**
+* Convert fraction string to number (return input value if conversion fails)
+* For historical reasons, numFraction returns the string value
+* unmodified if it is not able to convert to a number. This is
+* useful where user inputs are filtered through calls to
+* numFraction. For "detecting" when numFraction fails, check
+* if the return value is a string or a number. If it is a string
+* it means number conversion failed.
+*
+* @param str - fraction to be converted
+* @returns string or number with decimal format of fraction
+*/
+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") return str.charAt(0) === "-" ? -Infinity : Infinity;
+		console.warn("Error in numFraction() method: ", str);
+	}
+	return result.valueOf();
+}
+/**
+* Basic trimming of string values to remove leading and trailing spaces, tabs, newlines
+* @param value
+* @returns trimmed string
+*/
+const trim = (value) => value.trim().replace(/[\t\r\n]/g, "");
+/**
+* Cleaning up and fixing provided number to correct numerical format
+* removing redundant '.' dots, ',' commas, spaces
+* @param str - string for cleaning up
+* @returns cleaned/formatted string
+*/
+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 cleanedValue = value.replace(/^-/gm, "").replace(/^(?:0+(?=[1-9])|0+(?=0))/gm, "");
+	return isMinus ? `-${cleanedValue}` : cleanedValue;
+};
+/**
+* Cleaning and fixing numerical string but returns it as number
+* @param str - string for cleaning up
+* @returns number after cleanup and fixing
+*/
+function cleanNum(str) {
+	if (typeof str === "number") return str;
+	return parseFloat(cleanNumStr(str));
+}
+/**
+* Check if value is non-numerical
+*
+* @param value
+* @return boolean
+*/
+const isNonNumerical = (value) => !isNumeric(value);
+const { abs, exp, sqrt } = Math;
+/**
+* The 1D iterative Newton's method
+*
+* @param f
+* @param df
+* @param x0
+* @param tol
+* @param max_iter
+*/
+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
+	];
+}
+/**
+* Approximating the error function erf
+*
+* @param z
+*/
+function erf(z) {
+	const t = 1 / (1 + .5 * abs(z));
+	const ans = 1 - t * exp(-(z ** 2) - 1.26551223 + t * (1.00002368 + t * (.37409196 + t * (.09678418 + t * (-.18628806 + t * (.27886807 + t * (-1.13520398 + t * (1.48851587 + t * (-.82215223 + t * .17087277)))))))));
+	return z >= 0 ? ans : -ans;
+}
+/**
+* Convert from confidence interval to number of standard deviations
+*
+* @param a
+*/
+function get_k_from_conf_int(a) {
+	const f = (k) => a - erf(k / sqrt(2));
+	const df = (k) => -sqrt(2 / Math.PI) * exp(-.5 * k ** 2);
+	const [t0] = newton(f, df, 1);
+	return t0;
+}
+/**
+* Convert from number of standard deviations to confidence interval
+*
+* @param k
+*/
+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, exp) => {
+		let m = mantissa.endsWith(".") ? mantissa.slice(0, -1) : mantissa;
+		if (m.startsWith(".")) m = "0" + m;
+		const e = exp.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 [val, unit] = split(s);
+		return `${normalizeExponent(val.trim())}|${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);
+}
+//#endregion
+//#region src/constants.ts
+/**
+* Units labels
+*
+* @readonly
+* @enum {Object}
+*/
+const LABELS = Object.freeze({
+	in: "in",
+	mm: "mm",
+	cm: "cm",
+	m: "m",
+	microM: "μm",
+	km: "km",
+	ft: "ft",
+	usft: "usft",
+	in2: "in²",
+	cm2: "cm²",
+	m2: "m²",
+	kg: "kg",
+	tonnes: "t",
+	mt: "mt",
+	kip: "kip",
+	bbl: "bbl",
+	m3: "m³",
+	Mm3: "Mm³",
+	MMSCF: "MMSCF",
+	lbm: "lbm",
+	"kg/mol": "kg/mol",
+	"lbf/mol": "lbf/mol",
+	sg: "sg",
+	ppg: "ppg",
+	"kg/m3": "kg/m³",
+	"lbm/ft3": "lbm/ft³",
+	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³/min",
+	"m3/s": "m³/s",
+	MMSCFD: "MMSCFD",
+	bar: "Bar",
+	Pa: "Pa",
+	kPa: "kPa",
+	MPa: "MPa",
+	GPa: "GPa",
+	kPsi: "Psi",
+	ksi: "ksi",
+	"lbf/100ft2": "lbf/100ft²",
+	"1/Pa": "Pa⁻¹",
+	"1/kPa": "kPa⁻¹",
+	"1/MPa": "MPa⁻¹",
+	"1/GPa": "GPa⁻¹",
+	"1/psi": "psi⁻¹",
+	"kPa/m": "kPa/m",
+	"1/bar": "bar⁻¹",
+	klbf: "klbf",
+	"psi/ft": "Psi/ft",
+	"bar/100m": "bar/100m",
+	"psi/100ft": "psi/100ft",
+	"kPa/100m": "kPa/100m",
+	C: "°C",
+	F: "°F",
+	K: "K",
+	"C/100m": "°C/100m",
+	"C/m": "°C/m",
+	"Pa/C": "Pa/°C",
+	"Bar/C": "Bar/°C",
+	"psi/F": "psi/°F",
+	"psi/C": "psi/°C",
+	"F/100ft": "°F/100ft",
+	"F/ft": "°F/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⁻⁶/°C",
+	"E-06/degF": "10⁻⁶/°F",
+	"1/K": "K⁻¹",
+	km2: "km²",
+	ft2: "ft²",
+	mm2: "mm²",
+	mile2: "mile²",
+	ft3: "ft³",
+	"g/cm3": "g/cm³",
+	Sm3: "Sm³",
+	"ft3/s": "ft³/s",
+	"ft3/d": "ft³/d",
+	"m3/d": "m³/d",
+	"1/m3/d": "1/m³/d",
+	"s/m3": "s/m³",
+	"1/MMSCFD": "1/MMSCFD",
+	"bbl/d": "bbl/d",
+	tonneForce: "tonne-force",
+	USGal: "US gal",
+	"g/mol": "g/mol",
+	Nm: "N⋅m",
+	kNm: "kN⋅m",
+	ftlbf: "ft⋅lbf",
+	"J/(kg*degC)": "J/(kg⋅°C)",
+	"J/(kg*degK)": "J/(kg⋅K)",
+	"J/(s*m*degK)": "J/(s⋅m⋅K)",
+	"BTU/(lbm*degF)": "BTU/(lbm⋅°F)",
+	"BTU/(h*ft*degF)": "BTU/(h⋅ft⋅°F)",
+	l: "L",
+	"l/m": "L/m",
+	"kJ/kg": "kJ/kg",
+	"J/kg": "J/kg",
+	deg: "°",
+	"W/(mK)": "W/(m⋅K)",
+	psi: "psi",
+	"deg/100ft": "°/100ft",
+	"deg/30m": "°/30m",
+	"deg/10m": "°/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": "°/m",
+	"deg/ft": "°/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²",
+	Gs: "Gs",
+	nT: "nT",
+	g: "g",
+	"ft/s2": "ft/s²",
+	"Pa*s": "Pa⋅s",
+	P: "P",
+	"mPa*s": "mPa⋅s",
+	cP: "cP",
+	W: "W",
+	hhp: "hhp",
+	hp: "hp",
+	kW: "kW",
+	MW: "MW",
+	"BTU/h": "BTU/h",
+	"W/m2": "W/m²",
+	"hhp/in2": "hhp/in²",
+	"hhp/ft2": "hhp/ft²",
+	"Mm3/d": "Mm³/d",
+	"STB/d": "STB/d",
+	"Sm3/d": "Sm³/d",
+	"Sm3/min": "Sm³/min",
+	"MSm3/d": "MSm³/d",
+	"SCF/STB": "SCF / STB",
+	"Sm3/Sm3": "Sm³ / Sm³",
+	"SCF/d": "SCF/d",
+	STB: "STB",
+	SCF: "SCF",
+	MSm3: "MSm³",
+	Gsg: "sg",
+	Gppg: "ppg",
+	"Gkg/m3": "kg/m³",
+	"Glbm/ft3": "lbm/ft³",
+	"lb/ft3": "lb/ft³",
+	"°N": "°N",
+	"°S": "°S",
+	"°W": "°W",
+	"°E": "°E",
+	fr: " ",
+	mD: "mD",
+	CI: "CI",
+	Sigma: "σ",
+	"Sm3/d/bar": "Sm³/d/bar",
+	"STB/d/psi": "STB/d/psi",
+	"m3/s/bar": "m³/s/bar",
+	"lb/ft": "lb/ft",
+	"E-09/bar": "10⁻⁹/bar",
+	"E-10/psi": "10⁻¹⁰/psi",
+	"E-14/pa": "10⁻¹⁴/pa",
+	"m3/m": " m³/m",
+	"cm3/m": "cm³/m",
+	"mm3/m": "mm³/m",
+	"ft3/ft": "ft³/ft",
+	"in3/ft": "in³/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"
+});
+/**
+* Alternative units grouped by quantity
+*
+* @readonly
+* @enum {Object}
+*/
+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: ["°N", "°S"],
+	length: [
+		"m",
+		"cm",
+		"ft",
+		"km",
+		"in",
+		"mm"
+	],
+	linearCapacity: ["l/m", "bbl/ft"],
+	longitude: ["°E", "°W"],
+	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"
+	]
+});
+/**
+* Units list
+*
+* @readonly
+* @enum {Object}
+*/
+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",
+	interfacialTension: "dyn/cm",
+	deg: "deg",
+	dls: "deg/30m",
+	percentage: "%",
+	latitude: "°N",
+	longitude: "°E",
+	torque: "Nm",
+	rpm: "rpm",
+	testSingleUnit: "m",
+	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"
+});
+/**
+* Constants to help conversion
+*
+* @readonly
+* @enum {Object}
+*/
+const C = Object.freeze({
+	g: .0980665175317196,
+	ft_to_m: .3048,
+	inch_to_m: .0254,
+	lbf_to_kg: .45359237,
+	kg_to_lbf: 2.20462262184877,
+	ppf_to_kgm: .45359237 / .3048,
+	kg_cm3: .0293984025938081,
+	bar_to_psi: 14.503773773022,
+	bar_to_pascal: 1e5,
+	sg_to_ppg: 8.345404265,
+	bbl_to_m3: .158987294928,
+	USGal_to_m3: .003785411784,
+	kelvin_to_degrees: 273.15,
+	tonnes_to_pascal: 9806.65,
+	therm_exp_coeff: 1242e-8,
+	psi_to_pascal: 6894.757293168361,
+	ft3_to_m3: .028316846592,
+	ft3_to_in3: 1728,
+	day_to_second: 3600 * 24,
+	m3_per_m_to_ft3_per_ft: 10.763910416709722,
+	in3_per_ft_to_m3_per_m: 537633333333e-16,
+	MSm3d_to_m3s: 625 / 54
+});
+/**
+* Conversions list
+*
+* All unit conversion formulas should have a credible source/reference (please add a comment with URL to where you
+* got the formula when adding new units to this package). For example:
+*  - Wikipedia
+*  - https://www.nist.gov/pml/special-publication-811/nist-guide-si-appendix-b-conversion-factors/nist-guide-si-appendix-b8
+*  - https://www.wolframalpha.com/input?i=cubic+meter+to+bbl
+*
+* Do not round conversion factors in formulas (we need full precision). Make sure the inverse conversion (A->B->A)
+* produces a valid result.
+*
+* @readonly
+* @enum {Object}
+*/
+const KNOWN_CONVERSIONS = Object.freeze({
+	"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,
+	"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 * 3.861022e-7,
+	"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 / 3.861022e-7,
+	"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,
+	"Sm3|m3": (val) => val * 1,
+	"STB|m3": (val) => val * .1589948230919721,
+	"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,
+	"kg/m3|sg": (val) => val * .001,
+	"kg/m3|g/cm3": (val) => val * .001,
+	"kg/m3|lbm/ft3": (val) => val / 16.01846337,
+	"kg/m3|lb/ft3": (val) => val / 16.01846337,
+	"kg/m3|ppg": (val) => val * .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 / .008345404265,
+	"sg|kPa/m": (val) => val * 9.81,
+	"kPa/m|sg": (val) => val / 9.81,
+	"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,
+	"ppf|kg/m": (val) => val * .45359237 / .3048,
+	"kg/m|ppf": (val) => val * 1 / (.45359237 / .3048),
+	"kg/m|lbf/ft": (val) => val / .67196897675131,
+	"lbf/ft|kg/m": (val) => val * .67196897675131,
+	"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 * .001,
+	"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,
+	"lbf/100ft2|psi": (val) => val / 14400,
+	"1/psi|1/Pa": (val) => val / C.psi_to_pascal,
+	"1/bar|1/Pa": (val) => val * 1e-5,
+	"1/kPa|1/Pa": (val) => val * .001,
+	"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,
+	"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,
+	"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,
+	"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,
+	"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,
+	"psi/F|psi/C": (val) => val * 1.8,
+	"psi/C|psi/F": (val) => val / 1.8,
+	"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,
+	"kg|kip": (val) => val * C.kg_to_lbf * .001,
+	"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,
+	"kg/m|lb/ft": (val) => val * 1.4881639435695537,
+	"lb/ft|kg/m": (val) => val * .6719689751395069,
+	"kg|N": (val) => val * C.g * 100,
+	"N|kg": (val) => val / (C.g * 100),
+	"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,
+	"l/m|bbl/ft": (val) => val * .0019171343228277056,
+	"bbl/ft|l/m": (val) => val / .0019171343228277056,
+	"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,
+	"m3/s|MMSCFD": (val) => val / .32774128,
+	"m3/s|STB/d": (val) => val * 0x7a7f6097db00 / 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 * 3051187.2047366146,
+	"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,
+	"MMSCFD|m3/s": (val) => val * .32774128,
+	"Mm3/d|m3/d": (val) => val * 1e6,
+	"m3/d|Mm3/d": (val) => val * 1e-6,
+	"STB/d|m3/s": (val) => val * 184021785986e-17,
+	"Sm3/d|m3/d": (val) => val,
+	"m3/d|Sm3/d": (val) => val,
+	"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 * 3.2774128e-7,
+	"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,
+	"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 * .2519957611111111,
+	"lbm/s|tonnes/h": (val) => val * 1.632932532,
+	"tonnes/h|lbm/s": (val) => val * .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 * .90718474,
+	"mD|m2": (val) => val * 9869233e-19,
+	"m2|mD": (val) => val / 9869233e-19,
+	"N/m|lbf/ft": (val) => val * .22480894387096 * C.ft_to_m,
+	"lbf/ft|N/m": (val) => val / .22480894387096 / C.ft_to_m,
+	"dyn/cm|mN/m": (val) => val,
+	"mN/m|dyn/cm": (val) => val,
+	"dyn/cm|N/m": (val) => val * .001,
+	"N/m|dyn/cm": (val) => val * 1e3,
+	"mN/m|N/m": (val) => val * .001,
+	"N/m|mN/m": (val) => val * 1e3,
+	"Nm|ftlbf": (val) => val * .737562058700684,
+	"Nm|kNm": (val) => val / 1e3,
+	"kNm|Nm": (val) => val * 1e3,
+	"ftlbf|Nm": (val) => val / .737562058700684,
+	"N|kN": (val) => val * .001,
+	"N|kgf": (val) => val * 2e4 / 196133,
+	"N|lbf": (val) => val * 2e12 / 8896443230521,
+	"kN|lbf": (val) => val * 1e3 * 2e12 / 8896443230521,
+	"N|tonneForce": (val) => val * 20 / 196133,
+	"kN|N": (val) => val / .001,
+	"kgf|N": (val) => val * 196133 / 2e4,
+	"lbf|N": (val) => val * 8896443230521 / 2e12,
+	"lbf|kN": (val) => val * 8896443230521 / (2e12 * 1e3),
+	"lbf|tonneForce": (val) => val * 45359237 / 1e11,
+	"klbf|tonneForce": (val) => val * 45359237 / (1e11 * .001),
+	"tonneForce|N": (val) => val * 196133 / 20,
+	"tonneForce|lbf": (val) => val * 1e11 / 45359237,
+	"tonneForce|klbf": (val) => val * 1e11 / (45359237 * 1e3),
+	"klbf|lbf": (val) => val * 1e3,
+	"lbf|klbf": (val) => val / 1e3,
+	"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,
+	"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,
+	"%|fr": (val) => val * .01,
+	"fr|%": (val) => val / .01,
+	"deg|rad": (val) => val * Math.PI / 180,
+	"rad|deg": (val) => val * 180 / Math.PI,
+	"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,
+	"hp|hhp": (val) => val,
+	"°N|°S": (val) => val,
+	"°S|°N": (val) => val,
+	"°W|°E": (val) => val,
+	"°E|°W": (val) => val,
+	"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,
+	"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,
+	"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,
+	"rpm|Hz": (val) => val / 60,
+	"Hz|rpm": (val) => val * 60,
+	"CI|Sigma": (val) => get_k_from_conf_int(val),
+	"Sigma|CI": (val) => get_conf_int_from_k(val),
+	"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,
+	"m/s2|ft/s2": (val) => val / C.ft_to_m,
+	"ft/s2|m/s2": (val) => val * C.ft_to_m,
+	"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 * .001,
+	"Pa*s|cP": (val) => val / .001,
+	"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 * .001,
+	"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,
+	"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,
+	"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),
+	"SCF/STB|Sm3/Sm3": (val) => val * .178099173553719,
+	"Sm3/Sm3|SCF/STB": (val) => val * 5.614849187935035,
+	"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),
+	"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 * .001,
+	"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 * .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,
+	"Pa|lbf/100ft2": (val) => val * 2.088543423315013,
+	"lbf/100ft2|Pa": (val) => val * .4788025898033584,
+	"usft|m": (val) => val * .30480060960121924,
+	"lk|m": (val) => val * .201168,
+	"ftCla|m": (val) => val * .3047972651151,
+	"lkCla|m": (val) => val * .2011057269733667,
+	"ftGC|m": (val) => val * .30479971018150875,
+	"ydInd|m": (val) => val * .9143985307444408,
+	"ftSe|m": (val) => val * (12 / 39.370147),
+	"ydSe|m": (val) => val * .9143991154275526,
+	"chSe|m": (val) => val * 20.11676512155263,
+	"chSe(T)|m": (val) => val * 20.116756,
+	"m|usft": (val) => val / .30480060960121924,
+	"m|lk": (val) => val / .201168,
+	"m|ftCla": (val) => val / .3047972651151,
+	"m|lkCla": (val) => val / .2011057269733667,
+	"m|ftGC": (val) => val / .30479971018150875,
+	"m|ydInd": (val) => val / .9143985307444408,
+	"m|ftSe": (val) => val / (12 / 39.370147),
+	"m|ydSe": (val) => val / .9143991154275526,
+	"m|chSe": (val) => val / 20.11676512155263,
+	"m|chSe(T)": (val) => val / 20.116756,
+	"m3/t|L/100kg": (val) => val * 100,
+	"L/100kg|m3/t": (val) => val * .01,
+	"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,
+	"g|m/s2": (val) => val * 9.81,
+	"m/s2|g": (val) => val / 9.81,
+	"Gs|nT": (val) => val * 1e5,
+	"nT|Gs": (val) => val / 1e5
+});
+/**
+* Deprecated units
+*
+* @readonly
+* @enum {Object}
+*/
+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)"
+});
+/**
+* This list is mapping from legal alternative unit names to our selected unit name
+*
+* @readonly
+* @enum {Object}
+*/
+const UNIT_ALIASES = Object.freeze({
+	"lbs/ft": "lb/ft",
+	"lbm/ft": "lb/ft",
+	ftUS: "usft"
+});
+/**
+* Intermediate conversions
+*
+* @readonly
+* @enum {Object}
+*/
+const INTERMEDIATE_CONVERSIONS = Object.freeze({
+	mm: "m",
+	cm: "m",
+	km: "m",
+	ft: "m",
+	in: "m",
+	microM: "m",
+	lbf: "kg",
+	t: "kg",
+	tonnes: "kg",
+	mt: "kg",
+	kip: "kg",
+	kW: "W",
+	MW: "W",
+	hp: "W",
+	hhp: "hp",
+	mm2: "m2",
+	cm2: "m2",
+	km2: "m2",
+	in2: "m2",
+	ft2: "m2",
+	mile2: "m2",
+	bbl: "m3",
+	ft3: "m3",
+	Mm3: "m3",
+	l: "m3",
+	USGal: "m3",
+	Sm3: "m3",
+	STB: "m3",
+	MMSCF: "m3",
+	MSm3: "m3",
+	SCF: "m3",
+	kN: "N",
+	kgf: "N",
+	tonneForce: "N",
+	klbf: "lbf",
+	psi: "Pa",
+	bar: "Pa",
+	kPa: "Pa",
+	MPa: "Pa",
+	ksi: "psi",
+	"lbf/100ft2": "psi",
+	"psi/100ft": "Pa/m",
+	"psi/ft": "Pa/m",
+	"bar/100m": "Pa/m",
+	"bar/m": "Pa/m",
+	"Pa/m": "kPa/m",
+	sg: "kg/m3",
+	"g/cm3": "kg/m3",
+	"lbm/ft3": "kg/m3",
+	"lb/ft3": "kg/m3",
+	ppg: "kg/m3",
+	"kPa/m": "sg",
+	Gsg: "Gkg/m3",
+	Gppg: "Gkg/m3",
+	"Glbm/ft3": "Gkg/m3",
+	"1/psi": "1/Pa",
+	"1/bar": "1/Pa",
+	"1/kPa": "1/Pa",
+	"1/MPa": "1/Pa",
+	"1/GPa": "1/Pa",
+	"ft/s": "m/s",
+	"ft/min": "m/s",
+	"ft/h": "m/s",
+	"m/min": "m/s",
+	"m/h": "m/s",
+	mph: "m/s",
+	"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",
+	min: "s",
+	h: "s",
+	d: "s",
+	month: "d",
+	year: "d",
+	"J/(kg*degK)": "J/(kg*degC)",
+	"BTU/(lbm*degF)": "J/(kg*degC)",
+	"BTU/(Kg*K)": "J/(kg*degC)",
+	"BTU/(h*ft*degF)": "J/(s*m*degK)",
+	"W/(m*degK)": "J/(s*m*degK)",
+	"W/(mK)": "J/(s*m*degK)",
+	K: "C",
+	"C/m": "C/100m",
+	"F/ft": "C/100m",
+	"K/m": "C/100m",
+	"F/100ft": "C/100m",
+	"K/100m": "C/100m",
+	"Bar/C": "Pa/C",
+	"s/m3": "1/m3/d",
+	"1/MMSCFD": "1/m3/d",
+	P: "Pa*s",
+	"mPa*s": "Pa*s",
+	cP: "Pa*s",
+	"hhp/in2": "W/m2",
+	"hhp/ft2": "W/m2",
+	"Sm3/d/bar": "m3/s/bar",
+	"STB/d/psi": "m3/s/bar",
+	"deg/100ft": "deg/m",
+	"deg/30m": "deg/m",
+	"deg/10m": "deg/m",
+	"deg/ft": "deg/m",
+	"rad/ft": "deg/m",
+	"lbf/mol": "kg/mol",
+	"g/mol": "kg/mol",
+	"1/K": "E-06/degC",
+	"E-09/bar": "E-10/psi",
+	"E-14/pa": "E-10/psi",
+	"1/Pa": "E-14/pa",
+	kNm: "Nm",
+	ftlbf: "Nm",
+	lk: "m",
+	ftCla: "m",
+	lkCla: "m",
+	ftSe: "m",
+	ydSe: "m",
+	chSe: "m",
+	"chSe(T)": "m",
+	ftGC: "m",
+	ydInd: "m",
+	"BTU/lbm": "J/kg"
+});
+/**
+* List of all known units in application
+*
+* @readonly
+* @enum {string[]}
+*/
+const KNOWN_UNITS = Object.freeze(Array.from(new Set(Object.values(ALT_UNITS).flat())));
+const SPECIAL_NUMBERS_STRING = [
+	NaN,
+	-Infinity,
+	Infinity
+].map((number) => number.toString());
+/**
+* Description for the different quantites
+* @readonly
+*/
+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"
+};
+/**
+* Description for the different units
+* @readonly
+*/
+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",
+	"°N": "°N (latitude)",
+	"°S": "°S (latitude)",
+	"°W": "°W (longitude)",
+	"°E": "°E (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⁻¹⁰ per psi",
+	"E-14/pa": "10⁻¹⁴ 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"
+};
+//#endregion
+//#region src/validate/ajv-validators.ts
+var import_ucs2length = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	function ucs2length(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;
+	}
+	exports.default = ucs2length;
+	ucs2length.code = "require(\"ajv/dist/runtime/ucs2length\").default";
+})))(), 1);
+import_ucs2length.default.default ?? import_ucs2length.default;
+const numberSchemaValidator = validate15;
+function validate15(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+	validate15.errors = null;
+	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[1] === "/") {
+			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;
+}
+//#endregion
+//#region src/validate/errors-transform.ts
+const transformErrors = (errors) => {
+	return errors?.map(({ message }) => message);
+};
+//#endregion
+//#region src/units.ts
+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]+)?$/;
+/**
+* Get list of units for a given quantity
+*
+* @param quantityKey
+* @return []
+*/
+function showAltUnitsList(quantityKey) {
+	return ALT_UNITS[quantityKey];
+}
+/**
+* Get list of units for a given quantity
+*
+* @param quantity
+* @return [] | undefined
+*/
+function getUnitsForQuantity(quantity) {
+	return showAltUnitsList(quantity);
+}
+/**
+* Get list of all defined quantities
+* @returns []
+*/
+function getQuantities() {
+	return Object.keys(ALT_UNITS);
+}
+/**
+* Get unit label
+*
+* @param unitKey
+* @return string|undefined
+*/
+function label(unitKey) {
+	return LABELS[unitKey];
+}
+/**
+* Get unit by quantity
+*
+* @param quantity
+* @return string|undefined
+*/
+function unitFromKey(quantity) {
+	return UNIT_FROM_KEY[quantity];
+}
+/**
+* Get unit by quantity
+*
+* @param quantity
+* @return string|undefined
+*/
+function unitFromQuantity(quantity) {
+	return unitFromKey(quantity);
+}
+/**
+* Get list of alternative units, with labels, for a given quantity.
+*
+* @param quantity
+* @return AltUnitWithLabel[]|undefined
+*/
+function getAltUnitsListByQuantity(quantity) {
+	const quantityUnitList = showAltUnitsList(quantity);
+	return quantityUnitList ? quantityUnitList.map((unit) => ({
+		unit,
+		label: label(unit)
+	})) : void 0;
+}
+/**
+* Find double dot and comma in value and replace it with decimal dot.
+* For example: 123,4 => 123.4 or 123..4 => 123.4
+*
+* @param val
+* @return string|number
+*/
+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;
+}
+/**
+* Convert value to another unit
+*
+* @param value clean value without unit
+* @param fromUnit unit from which we are trying to convert
+* @param toUnit unit to which we are trying to convert
+* @return number|Error
+*/
+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) return to(to(value, fromUnit, int_from), int_from, toUnit);
+	else {
+		const int_to = INTERMEDIATE_CONVERSIONS[toUnit];
+		if (toUnit && int_to && int_to !== toUnit) return to(to(value, fromUnit, int_to), int_to, toUnit);
+	}
+	console.error("no conversions found", value, fromUnit, "->", toUnit);
+	throw new Error("No conversions found: " + value + " " + fromUnit + " -> " + toUnit);
+}
+/**
+* Split string into value and unit
+*
+* @param numWithUnit
+* @return string[] where first element it's actual value and second unit
+*/
+function split(numWithUnit) {
+	let m;
+	let vu = numWithUnit !== void 0 && numWithUnit !== null ? String(numWithUnit) : "";
+	if (charCount("|", vu) > 1) {
+		m = vu.split("|");
+		vu = m.slice(0, -1).join("") + "|" + m.slice(-1);
+	}
+	if (vu.indexOf("|") >= 0) m = vu.split("|");
+	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]];
+}
+/**
+* Get value of the number with unit string ("1|m") will return "1"
+* @param {sting} numWithUnit
+* @returns {string}
+*/
+function getValue(numWithUnit) {
+	return split(numWithUnit)[0];
+}
+/**
+* Get unit of the number with unit string ("1|m") will return "m"
+* @param {sting} numWithUnit
+* @returns {string}
+*/
+function getUnit(numWithUnit) {
+	return split(numWithUnit)[1];
+}
+/**
+* Convert value with unit to another unit
+*
+* @param numWithUnit value with unit
+* @param toUnit unit to which we are trying to convert
+* @param fromUnit unit from which we are trying to convert
+*/
+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 m = split(cleanNumStr(normalizeScientific(numWithUnit)).replaceAll("+", ""));
+	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);
+}
+/**
+* Takes user input and returns true if it was input with unit and false in every other case
+*
+* @param {String|Number} value
+* @returns {Boolean}
+*/
+function isValueWithUnit(value) {
+	if (!value) return false;
+	const splittedValue = String(value).split("|");
+	return splittedValue.length === 2 && KNOWN_UNITS.includes(splittedValue[1]);
+}
+/**
+* Convert value to another unit
+*
+* @param numWithUnit value (with optional unit string)
+* @param toUnit unit to which we are trying to convert
+* @param fromUnit unit from which we are trying to convert
+*/
+function convertAndGetValue(numWithUnit, toUnit, fromUnit) {
+	return unum(numWithUnit, toUnit, fromUnit);
+}
+/**
+* Convert value to another unit (preserves types and empty values)
+*
+* @param value value (with optional unit string)
+* @param toUnit unit to which we are trying to convert
+* @param fromUnit unit from which we are trying to convert
+*/
+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;
+}
+/**
+* Convert value to the base unit given by the quantity
+*
+* @param value
+* @param quantity
+* @return number
+*/
+function toBase(value, quantity) {
+	const to_unit = unitFromKey(quantity);
+	return unum(value, to_unit, split((value || "").toString())[1] || to_unit);
+}
+/**
+* Convert table of values to another unit
+*
+* @param toUnitRow array of units to which we are trying to convert for example: ['ft', 'ppg']
+* @param table array which represent table for example:
+* [['m', 'sg'],
+[100, 1],
+[1000, 1.25],
+[2000, 1.5],
+[3000, 1.1]]
+* @param defaultUnitRow
+* @param removeFinalUnitsRow if true first table row where we define units will be removed
+*/
+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 tableHasUnits = !(splittedFirstCell && splittedFirstCell[0] && isNaN(splittedFirstCell[1])) && 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;
+}
+/**
+* Rounds a unit string to N decimal places and appends formatted unit label
+*
+* @param value
+* @param n number of decimal digits
+* @return rounded value with formatted units
+*/
+function roundNumberWithLabel(value, n = 2) {
+	return displayNumber(round(value, n), { withUnit: true });
+}
+/**
+* Get value with unit splitted by | separator
+*
+* @param value
+* @param unit
+* @param defaultVal
+* @return string
+*/
+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("|") ? split(String(value)) : [value, unit];
+	if (!u) u = unit;
+	return [v, u].join("|");
+}
+/**
+* Converts to given toUnit and return the converted value with unit.
+* @see roundNumberWithLabel
+*
+* @param numWithUnit value with unit
+* @param toUnit unit to which we are trying to convert
+* @param fromUnit unit from which we are trying to convert
+* @return {string} - "number converted | unit"
+*/
+function unumWithUnit(numWithUnit, toUnit, fromUnit) {
+	return withUnit(unum(numWithUnit, toUnit, fromUnit), toUnit);
+}
+/**
+* Convert value with unit to another unit and display it in pretty format.
+* It will preserv the number of digits in the input or alternativly converting to the given number of digits
+*
+* @param {string|number} numWithUnit - value with unit
+* @param {string} toUnit - unit to which we are trying to convert
+* @param {number} digits - optional number of digits to round the number
+* @returns {string} - converted number including the unit (number|unit)
+*/
+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);
+}
+/**
+* Get list of values, with same precision as the given value, in all the units of the given quantity
+*
+* @param {string} value
+* @param {string} quantity
+* @return {[][string, string, string]}
+*/
+function altUnitsList(value, quantity) {
+	let v = value;
+	if (!getUnit(value)) v = withUnit(value, unitFromQuantity(quantity) ?? "");
+	return (ALT_UNITS[quantity] ?? []).map((unit) => [...split(convertSamePrecision(v, unit)), label(unit)]);
+}
+/**
+* Validates and cleans raw text numeric user input, typically from UnitInput
+* The previous value is for optionally determining the pre-existing unit
+* The next text is a raw input string
+* The return value is reformatted from the next text (removing invalid patterns)
+*
+* @param {String} previousValue with optional unit e.g. `25|m`
+* @param {String} nextText raw text for next value e.g. `26` (no unit)
+* @returns {String} e.g. `26|m`
+*/
+function validateAndClean(previousValue, nextText) {
+	const unit = split(previousValue)[1];
+	const cleanedValue = nextText.replace(/[^0-9.,-Ee]/g, "").replace(/^([^(e|E)]*[eE])|[eE]/g, "$1").replace(/^[E|e]*|[E|e]*$/g, "").replace(/,/g, ".").replace(/^([^.]*\.)|\./g, "$1").replace(/\.(?=e)/g, "").replace(/-|[eE]-/g, (match, offset) => offset === 0 || match.toLowerCase() === "e-" ? match : "");
+	return !Number.isFinite(+cleanedValue) ? previousValue : `${cleanedValue}${unit ? "|" : ""}${unit}`;
+}
+/**
+* Takes string included value with units and return display it in pretty format.
+*
+* @param {String} valueWithUnits
+* @returns {String}
+*/
+function withPrettyUnitLabel(valueWithUnits) {
+	const [val, unit] = split(valueWithUnits);
+	return `${val} ${LABELS[unit] ?? ""}`;
+}
+function validateNumber(value) {
+	let val = value;
+	if (typeof value === "string" && isValueWithUnit(value)) val = getValue(value);
+	val = checkAndCleanDecimalComma(val);
+	if (isNumeric(val)) return {
+		valid: numberSchemaValidator(toNum(val)),
+		errors: transformErrors(numberSchemaValidator.errors)
+	};
+	return {
+		valid: numberSchemaValidator(val),
+		errors: transformErrors(numberSchemaValidator.errors)
+	};
+}
+//#endregion
+export { displayNumber as $, DEPRECATED_UNITS as A, asFraction as B, unum as C, withPrettyUnitLabel as D, validateNumber as E, QUANTITIES_DESCRIPTION as F, fraction as G, cleanNum as H, UNITS_DESCRIPTION as I, isFraction as J, getNumberOfDigitsToShow as K, UNIT_ALIASES as L, KNOWN_CONVERSIONS as M, KNOWN_UNITS as N, withUnit as O, LABELS as P, stripLeadingZeros as Q, UNIT_FROM_KEY as R, unitFromQuantity as S, validateAndClean as T, cleanNumStr as U, charCount as V, formatNumber as W, isNumeric as X, isNonNumerical as Y, numFraction as Z, showAltUnitsList as _, convertAndGetValue as a, roundToDecimalPrecision as at, toBase as b, convertTable as c, isCloseTo as ct, getUnit as d, isDeepCloseTo as dt, displayNumberToFixed as et, getUnitsForQuantity as f, isScientificStringNum as ft, roundNumberWithLabel as g, label as h, toString as ht, checkAndCleanDecimalComma as i, roundByRange as it, INTERMEDIATE_CONVERSIONS as j, ALT_UNITS as k, getAltUnitsListByQuantity as l, isCloseToOrGreaterThan as lt, isValueWithUnit as m, toNum as mt, SEPARATOR as n, roundByMagnitude as nt, convertAndGetValueStrict as o, roundToFixed as ot, getValue as p, isValidNum as pt, isEmptyValueWithUnit as q, altUnitsList as r, roundByMagnitudeToFixed as rt, convertSamePrecision as s, roundToPrecision as st, EXP_NOTATION_RE as t, round as tt, getQuantities as u, isCloseToOrLessThan as ut, split as v, unumWithUnit as w, unitFromKey as x, to as y, allNumbers as z };
+
+//# sourceMappingURL=units2.js.map