@oliasoft-open-source/units 4.7.0 → 5.0.0-beta-1

package/dist/units2.cjs

@@ -0,0 +1,3563 @@
+//#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
+let fraction_js = require("fraction.js");
+fraction_js = __toESM(fraction_js, 1);
+//#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_js.default(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_js.default(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_js.default(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_js.default(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
+Object.defineProperty(exports, "ALT_UNITS", {
+	enumerable: true,
+	get: function() {
+		return ALT_UNITS;
+	}
+});
+Object.defineProperty(exports, "DEPRECATED_UNITS", {
+	enumerable: true,
+	get: function() {
+		return DEPRECATED_UNITS;
+	}
+});
+Object.defineProperty(exports, "EXP_NOTATION_RE", {
+	enumerable: true,
+	get: function() {
+		return EXP_NOTATION_RE;
+	}
+});
+Object.defineProperty(exports, "INTERMEDIATE_CONVERSIONS", {
+	enumerable: true,
+	get: function() {
+		return INTERMEDIATE_CONVERSIONS;
+	}
+});
+Object.defineProperty(exports, "KNOWN_CONVERSIONS", {
+	enumerable: true,
+	get: function() {
+		return KNOWN_CONVERSIONS;
+	}
+});
+Object.defineProperty(exports, "KNOWN_UNITS", {
+	enumerable: true,
+	get: function() {
+		return KNOWN_UNITS;
+	}
+});
+Object.defineProperty(exports, "LABELS", {
+	enumerable: true,
+	get: function() {
+		return LABELS;
+	}
+});
+Object.defineProperty(exports, "QUANTITIES_DESCRIPTION", {
+	enumerable: true,
+	get: function() {
+		return QUANTITIES_DESCRIPTION;
+	}
+});
+Object.defineProperty(exports, "SEPARATOR", {
+	enumerable: true,
+	get: function() {
+		return SEPARATOR;
+	}
+});
+Object.defineProperty(exports, "UNITS_DESCRIPTION", {
+	enumerable: true,
+	get: function() {
+		return UNITS_DESCRIPTION;
+	}
+});
+Object.defineProperty(exports, "UNIT_ALIASES", {
+	enumerable: true,
+	get: function() {
+		return UNIT_ALIASES;
+	}
+});
+Object.defineProperty(exports, "UNIT_FROM_KEY", {
+	enumerable: true,
+	get: function() {
+		return UNIT_FROM_KEY;
+	}
+});
+Object.defineProperty(exports, "allNumbers", {
+	enumerable: true,
+	get: function() {
+		return allNumbers;
+	}
+});
+Object.defineProperty(exports, "altUnitsList", {
+	enumerable: true,
+	get: function() {
+		return altUnitsList;
+	}
+});
+Object.defineProperty(exports, "asFraction", {
+	enumerable: true,
+	get: function() {
+		return asFraction;
+	}
+});
+Object.defineProperty(exports, "charCount", {
+	enumerable: true,
+	get: function() {
+		return charCount;
+	}
+});
+Object.defineProperty(exports, "checkAndCleanDecimalComma", {
+	enumerable: true,
+	get: function() {
+		return checkAndCleanDecimalComma;
+	}
+});
+Object.defineProperty(exports, "cleanNum", {
+	enumerable: true,
+	get: function() {
+		return cleanNum;
+	}
+});
+Object.defineProperty(exports, "cleanNumStr", {
+	enumerable: true,
+	get: function() {
+		return cleanNumStr;
+	}
+});
+Object.defineProperty(exports, "convertAndGetValue", {
+	enumerable: true,
+	get: function() {
+		return convertAndGetValue;
+	}
+});
+Object.defineProperty(exports, "convertAndGetValueStrict", {
+	enumerable: true,
+	get: function() {
+		return convertAndGetValueStrict;
+	}
+});
+Object.defineProperty(exports, "convertSamePrecision", {
+	enumerable: true,
+	get: function() {
+		return convertSamePrecision;
+	}
+});
+Object.defineProperty(exports, "convertTable", {
+	enumerable: true,
+	get: function() {
+		return convertTable;
+	}
+});
+Object.defineProperty(exports, "displayNumber", {
+	enumerable: true,
+	get: function() {
+		return displayNumber;
+	}
+});
+Object.defineProperty(exports, "displayNumberToFixed", {
+	enumerable: true,
+	get: function() {
+		return displayNumberToFixed;
+	}
+});
+Object.defineProperty(exports, "formatNumber", {
+	enumerable: true,
+	get: function() {
+		return formatNumber;
+	}
+});
+Object.defineProperty(exports, "fraction", {
+	enumerable: true,
+	get: function() {
+		return fraction;
+	}
+});
+Object.defineProperty(exports, "getAltUnitsListByQuantity", {
+	enumerable: true,
+	get: function() {
+		return getAltUnitsListByQuantity;
+	}
+});
+Object.defineProperty(exports, "getNumberOfDigitsToShow", {
+	enumerable: true,
+	get: function() {
+		return getNumberOfDigitsToShow;
+	}
+});
+Object.defineProperty(exports, "getQuantities", {
+	enumerable: true,
+	get: function() {
+		return getQuantities;
+	}
+});
+Object.defineProperty(exports, "getUnit", {
+	enumerable: true,
+	get: function() {
+		return getUnit;
+	}
+});
+Object.defineProperty(exports, "getUnitsForQuantity", {
+	enumerable: true,
+	get: function() {
+		return getUnitsForQuantity;
+	}
+});
+Object.defineProperty(exports, "getValue", {
+	enumerable: true,
+	get: function() {
+		return getValue;
+	}
+});
+Object.defineProperty(exports, "isCloseTo", {
+	enumerable: true,
+	get: function() {
+		return isCloseTo;
+	}
+});
+Object.defineProperty(exports, "isCloseToOrGreaterThan", {
+	enumerable: true,
+	get: function() {
+		return isCloseToOrGreaterThan;
+	}
+});
+Object.defineProperty(exports, "isCloseToOrLessThan", {
+	enumerable: true,
+	get: function() {
+		return isCloseToOrLessThan;
+	}
+});
+Object.defineProperty(exports, "isDeepCloseTo", {
+	enumerable: true,
+	get: function() {
+		return isDeepCloseTo;
+	}
+});
+Object.defineProperty(exports, "isEmptyValueWithUnit", {
+	enumerable: true,
+	get: function() {
+		return isEmptyValueWithUnit;
+	}
+});
+Object.defineProperty(exports, "isFraction", {
+	enumerable: true,
+	get: function() {
+		return isFraction;
+	}
+});
+Object.defineProperty(exports, "isNonNumerical", {
+	enumerable: true,
+	get: function() {
+		return isNonNumerical;
+	}
+});
+Object.defineProperty(exports, "isNumeric", {
+	enumerable: true,
+	get: function() {
+		return isNumeric;
+	}
+});
+Object.defineProperty(exports, "isScientificStringNum", {
+	enumerable: true,
+	get: function() {
+		return isScientificStringNum;
+	}
+});
+Object.defineProperty(exports, "isValidNum", {
+	enumerable: true,
+	get: function() {
+		return isValidNum;
+	}
+});
+Object.defineProperty(exports, "isValueWithUnit", {
+	enumerable: true,
+	get: function() {
+		return isValueWithUnit;
+	}
+});
+Object.defineProperty(exports, "label", {
+	enumerable: true,
+	get: function() {
+		return label;
+	}
+});
+Object.defineProperty(exports, "numFraction", {
+	enumerable: true,
+	get: function() {
+		return numFraction;
+	}
+});
+Object.defineProperty(exports, "round", {
+	enumerable: true,
+	get: function() {
+		return round;
+	}
+});
+Object.defineProperty(exports, "roundByMagnitude", {
+	enumerable: true,
+	get: function() {
+		return roundByMagnitude;
+	}
+});
+Object.defineProperty(exports, "roundByMagnitudeToFixed", {
+	enumerable: true,
+	get: function() {
+		return roundByMagnitudeToFixed;
+	}
+});
+Object.defineProperty(exports, "roundByRange", {
+	enumerable: true,
+	get: function() {
+		return roundByRange;
+	}
+});
+Object.defineProperty(exports, "roundNumberWithLabel", {
+	enumerable: true,
+	get: function() {
+		return roundNumberWithLabel;
+	}
+});
+Object.defineProperty(exports, "roundToDecimalPrecision", {
+	enumerable: true,
+	get: function() {
+		return roundToDecimalPrecision;
+	}
+});
+Object.defineProperty(exports, "roundToFixed", {
+	enumerable: true,
+	get: function() {
+		return roundToFixed;
+	}
+});
+Object.defineProperty(exports, "roundToPrecision", {
+	enumerable: true,
+	get: function() {
+		return roundToPrecision;
+	}
+});
+Object.defineProperty(exports, "showAltUnitsList", {
+	enumerable: true,
+	get: function() {
+		return showAltUnitsList;
+	}
+});
+Object.defineProperty(exports, "split", {
+	enumerable: true,
+	get: function() {
+		return split;
+	}
+});
+Object.defineProperty(exports, "stripLeadingZeros", {
+	enumerable: true,
+	get: function() {
+		return stripLeadingZeros;
+	}
+});
+Object.defineProperty(exports, "to", {
+	enumerable: true,
+	get: function() {
+		return to;
+	}
+});
+Object.defineProperty(exports, "toBase", {
+	enumerable: true,
+	get: function() {
+		return toBase;
+	}
+});
+Object.defineProperty(exports, "toNum", {
+	enumerable: true,
+	get: function() {
+		return toNum;
+	}
+});
+Object.defineProperty(exports, "toString", {
+	enumerable: true,
+	get: function() {
+		return toString;
+	}
+});
+Object.defineProperty(exports, "unitFromKey", {
+	enumerable: true,
+	get: function() {
+		return unitFromKey;
+	}
+});
+Object.defineProperty(exports, "unitFromQuantity", {
+	enumerable: true,
+	get: function() {
+		return unitFromQuantity;
+	}
+});
+Object.defineProperty(exports, "unum", {
+	enumerable: true,
+	get: function() {
+		return unum;
+	}
+});
+Object.defineProperty(exports, "unumWithUnit", {
+	enumerable: true,
+	get: function() {
+		return unumWithUnit;
+	}
+});
+Object.defineProperty(exports, "validateAndClean", {
+	enumerable: true,
+	get: function() {
+		return validateAndClean;
+	}
+});
+Object.defineProperty(exports, "validateNumber", {
+	enumerable: true,
+	get: function() {
+		return validateNumber;
+	}
+});
+Object.defineProperty(exports, "withPrettyUnitLabel", {
+	enumerable: true,
+	get: function() {
+		return withPrettyUnitLabel;
+	}
+});
+Object.defineProperty(exports, "withUnit", {
+	enumerable: true,
+	get: function() {
+		return withUnit;
+	}
+});
+
+//# sourceMappingURL=units2.cjs.map