@oliasoft-open-source/units 5.5.2-beta-2 → 5.6.0-beta-4

package/dist/{units2.cjs → chunks/conversion.cjs}

@@ -23,1165 +23,281 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 //#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);
+//#region src/numbers/statistics/confidence-interval.ts
+const { abs, exp, sqrt } = Math;
+/** Applies the one-dimensional iterative Newton method. */
+function newton(functionValue, derivative, initialValue, tolerance = 1e-8, maxIterations = 30) {
+	let currentValue = initialValue;
+	let iteration = 0;
+	let error = 1;
+	while (error > tolerance && iteration < maxIterations) {
+		const nextValue = currentValue - functionValue(currentValue) / derivative(currentValue);
+		error = abs(functionValue(nextValue) - functionValue(currentValue));
+		if (error < tolerance) return [
+			nextValue,
+			true,
+			iteration
+		];
+		currentValue = nextValue;
+		iteration += 1;
 	}
-	return numberFormat.format(number);
+	return [
+		initialValue,
+		false,
+		iteration
+	];
 }
-//#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
+/** Approximates the Gaussian error function. */
+function erf(value) {
+	const t = 1 / (1 + .5 * abs(value));
+	const answer = 1 - t * exp(-(value ** 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 value >= 0 ? answer : -answer;
+}
+/** Converts a confidence interval to a number of standard deviations. */
+function get_k_from_conf_int(confidenceInterval) {
+	const functionValue = (value) => {
+		return confidenceInterval - erf(value / sqrt(2));
 	};
-};
-/**
-* 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) : 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 derivative = (value) => {
+		return -sqrt(2 / Math.PI) * exp(-.5 * value ** 2);
 	};
-};
-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;
-};
+	const [result] = newton(functionValue, derivative, 1);
+	return result;
+}
+/** Converts a number of standard deviations to a confidence interval. */
+function get_conf_int_from_k(standardDeviations) {
+	return erf(standardDeviations / sqrt(2));
+}
 //#endregion
-//#region src/rounding/rounding.ts
-const DEFAULT_SIGNIFICANT_DIGITS = 4;
+//#region src/units/constants.ts
 /**
-* Rounds a number to N decimal places.
+* Units labels
 *
-* @private (see round() for the public interface)
-* @param value
-* @param [n]
-* @returns rounded number
+* @readonly
+* @enum {Object}
 */
-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)
-	});
-};
+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"
+});
 /**
-* Rounds a number to N significant digits.
+* Alternative units grouped by quantity
 *
-* @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}
+* @readonly
+* @enum {Object}
 */
 const ALT_UNITS = Object.freeze({
 	acceleration: ["ft/s2", "m/s2"],
@@ -1618,13 +734,6 @@ const ALT_UNITS = Object.freeze({
 		"ft3/ft",
 		"in3/ft"
 	],
-	wellheadGrowthMovement: [
-		"mm",
-		"cm",
-		"m",
-		"in",
-		"ft"
-	],
 	shearStress: ["Pa", "lbf/100ft2"],
 	sensorAccelerometer: ["g", "m/s2"],
 	sensorMagnetometer: ["nT", "Gs"],
@@ -1707,7 +816,6 @@ const UNIT_FROM_KEY = Object.freeze({
 	entalphy: "J/kg",
 	shearStress: "Pa",
 	volumeGradient: "m3/m",
-	wellheadGrowthMovement: "m",
 	sensorAccelerometer: "g",
 	sensorMagnetometer: "Gs"
 });
@@ -2197,495 +1305,1381 @@ const KNOWN_CONVERSIONS = Object.freeze({
 	"nT|Gs": (val) => val / 1e5
 });
 /**
-* Deprecated units
+* 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/units/unit-catalog.ts
+/** Returns the units configured for a quantity key. */
+function showAltUnitsList(quantityKey) {
+	return ALT_UNITS[quantityKey];
+}
+/** Returns the units configured for a quantity. */
+function getUnitsForQuantity(quantity) {
+	return showAltUnitsList(quantity);
+}
+/** Returns all configured quantity keys. */
+function getQuantities() {
+	return Object.keys(ALT_UNITS);
+}
+/** Returns the display label for a unit key. */
+function label(unitKey) {
+	return LABELS[unitKey];
+}
+/** Returns the base unit configured for a quantity. */
+function unitFromKey(quantity) {
+	return UNIT_FROM_KEY[quantity];
+}
+/** Alias for `unitFromKey`. */
+function unitFromQuantity(quantity) {
+	return unitFromKey(quantity);
+}
+/** Returns the alternative units and their display labels for a quantity. */
+function getAltUnitsListByQuantity(quantity) {
+	const quantityUnitList = showAltUnitsList(quantity);
+	return quantityUnitList ? quantityUnitList.map((unit) => ({
+		unit,
+		label: label(unit)
+	})) : void 0;
+}
+//#endregion
+//#region src/numbers/parsing/number-input.ts
+/** Basic trimming of numeric input strings. */
+const trim = (value) => {
+	return value.trim().replace(/[\t\r\n]/g, "");
+};
+/** Counts occurrences of a character in a string. */
+function charCount(character, value) {
+	const singleCharacter = String(character)[0];
+	let total = 0;
+	let lastLocation = value.indexOf(singleCharacter, 0) + 1;
+	while (lastLocation > 0) {
+		lastLocation = value.indexOf(singleCharacter, lastLocation) + 1;
+		total += 1;
+	}
+	return total;
+}
+/** Normalizes supported decimal and thousands separators in a numeric input string. */
+function cleanNumStr(value) {
+	let cleanString = trim(String(value));
+	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;
+}
+/** Removes redundant leading zeros while preserving the sign and fractional part. */
+const stripLeadingZeros = (value) => {
+	const isMinus = value?.[0] === "-";
+	const cleanedValue = value.replace(/^-/gm, "").replace(/^(?:0+(?=[1-9])|0+(?=0))/gm, "");
+	return isMinus ? `-${cleanedValue}` : cleanedValue;
+};
+/** Normalizes a numeric input string and parses it as a number. */
+function cleanNum(value) {
+	if (typeof value === "number") return value;
+	return parseFloat(cleanNumStr(value));
+}
+const isNull = (value) => {
+	return value === null;
+};
+const isUndefined = (value) => {
+	return value === void 0;
+};
+const isArray = (value) => {
+	return Boolean(value) && value.constructor === Array;
+};
+const isObject = (value) => {
+	return Boolean(value) && value.constructor === Object;
+};
+const isEmptyString = (value) => {
+	return value === "";
+};
+const isTrailingPeriodSeparator = (value) => {
+	return Boolean(value) && String(value)[String(value).length - 1] === ".";
+};
+const isTrailingCommaSeparator = (value) => {
+	return Boolean(value) && String(value)[String(value).length - 1] === ",";
+};
+//#endregion
+//#region src/units/unit-string.ts
+const SEPARATOR = "|";
+const UNIT_RE = /^(-?[0-9., /]*?(?:e[-+]?[0-9]+)?)([^0-9-., /].*)?$/;
+/** Checks whether a unit string has an empty numeric part, for example `|m`. */
+function isEmptyValueWithUnit(value) {
+	return typeof value === "string" && value.length > 0 && value.startsWith("|");
+}
+/** Splits a supported unit string into its numeric and unit parts. */
+function split(valueWithUnit) {
+	let match;
+	let normalizedValue = valueWithUnit !== void 0 && valueWithUnit !== null ? String(valueWithUnit) : "";
+	if (charCount("|", normalizedValue) > 1) {
+		match = normalizedValue.split("|");
+		normalizedValue = match.slice(0, -1).join("") + "|" + match.slice(-1);
+	}
+	if (normalizedValue.indexOf("|") >= 0) match = normalizedValue.split("|");
+	else if (SPECIAL_NUMBERS_STRING.includes(normalizedValue)) match = [normalizedValue, ""];
+	else {
+		match = cleanNumStr(normalizedValue).match(UNIT_RE);
+		if (match) match = match.slice(1);
+	}
+	if (!match) match = ["0", ""];
+	if (match[1] == null) match[1] = "";
+	return [match[0], match[1]];
+}
+/** Returns the numeric part of a unit string. */
+function getValue(valueWithUnit) {
+	return split(valueWithUnit)[0];
+}
+/** Returns the unit part of a unit string. */
+function getUnit(valueWithUnit) {
+	return split(valueWithUnit)[1];
+}
+/** Checks whether a value contains exactly one known unit suffix. */
+function isValueWithUnit(value) {
+	if (!value) return false;
+	const parts = String(value).split("|");
+	return parts.length === 2 && KNOWN_UNITS.includes(parts[1]);
+}
+/** Joins a value and unit using the package unit separator. */
+function withUnit(value, unit, defaultValue = "") {
+	if (value === null || value === "" || value === void 0) value = defaultValue;
+	if (unit === null) return String(value);
+	let [normalizedValue, normalizedUnit] = String(value).includes("|") ? split(String(value)) : [value, unit];
+	if (!normalizedUnit) normalizedUnit = unit;
+	return [normalizedValue, normalizedUnit].join("|");
+}
+/** Replaces a unit key in a unit string with its display label. */
+function withPrettyUnitLabel(valueWithUnits) {
+	const [value, unit] = split(valueWithUnits);
+	return `${value} ${LABELS[unit] ?? ""}`;
+}
+//#endregion
+//#region src/numbers/fractions/fractions.ts
+const normalizeFractionWhitespace = (value) => {
+	return value.trim().replace(/\s+/g, " ");
+};
+/** Checks whether a string can be parsed as a fraction by fraction.js. */
+const isFraction = (value) => {
+	if (typeof value !== "string" || !value.includes("/")) return false;
+	try {
+		new fraction_js.default(normalizeFractionWhitespace(value));
+		return true;
+	} catch (error) {
+		return error.message === "Division by Zero";
+	}
+};
+/** Converts a fraction to its decimal value, or returns `NaN` when it cannot be parsed. */
+function fraction(value) {
+	if (value instanceof Array || value === null || value === void 0) return NaN;
+	if (typeof value === "string") value = normalizeFractionWhitespace(value);
+	if (value === "") return NaN;
+	let result = NaN;
+	let infinite = false;
+	try {
+		const fractionObject = new fraction_js.default(value);
+		if (fractionObject !== void 0) result = fractionObject.valueOf();
+	} catch (error) {
+		if (error instanceof Error && error.message === "Division by Zero") infinite = true;
+	}
+	return infinite ? Infinity : result;
+}
+/** Converts a decimal value to a fractional string. */
+function asFraction(value) {
+	if (typeof value === "string") value = normalizeFractionWhitespace(value);
+	if (value === "") value = "0";
+	return new fraction_js.default(value).toFraction(true);
+}
+/**
+* Converts a fraction string to a number.
+*
+* For compatibility, invalid inputs are returned unchanged and division by zero returns signed infinity.
+*/
+function numFraction(value) {
+	if (value instanceof Array || value === null || value === void 0 || value === "" || value === Infinity || value === -Infinity || value === "Infinity" || value === "-Infinity" || Number.isNaN(value) || value === "NaN") return value;
+	if (typeof value === "string") value = normalizeFractionWhitespace(value);
+	let result = value;
+	try {
+		const fractionObject = new fraction_js.default(value);
+		if (fractionObject !== void 0) result = fractionObject.valueOf();
+	} catch (error) {
+		if (error.message === "Division by Zero") return value.charAt(0) === "-" ? -Infinity : Infinity;
+		console.warn("Error in numFraction() method: ", value);
+	}
+	return result.valueOf();
+}
+//#endregion
+//#region src/numbers/scientific-notation/scientific-notation.ts
+const EXP_NOTATION_RE = /^[-+]?[0-9]*\.?[0-9]+(?:\/[0-9]*\.?[0-9]+)?(?:[eE][-+]?[0-9]+)?$/;
+/** Normalizes whitespace and mantissa syntax in a scientific-notation string. */
+const normalizeExponent = (input) => {
+	return input.replace(/^([+-]?(?:\d+\.?\d*|\.\d+))[ ]*[eE][ ]*([+-]?[ ]*\d+)/, (_match, mantissa, exponent) => {
+		let normalizedMantissa = mantissa.endsWith(".") ? mantissa.slice(0, -1) : mantissa;
+		if (normalizedMantissa.startsWith(".")) normalizedMantissa = `0${normalizedMantissa}`;
+		const normalizedExponent = exponent.replace(/[ ]+/g, "");
+		return `${normalizedMantissa}e${normalizedExponent}`;
+	});
+};
+/** Normalizes scientific notation while preserving an optional unit suffix. */
+function normalizeScientific(value) {
+	if (typeof value !== "string") return value;
+	const normalizedSpaces = value.replace(/\u00A0|\u2007|\u202F/g, " ").trim();
+	if (isValueWithUnit(normalizedSpaces)) {
+		const [number, unit] = split(normalizedSpaces);
+		return `${normalizeExponent(number.trim())}|${unit.trim()}`;
+	}
+	const match = normalizedSpaces.match(/^([+-]?(?:\d+(?:\.\d*)?|\.\d+)\s*[eE]\s*[+-]?\s*\d+)\s+(.+)$/);
+	if (match) return `${normalizeExponent(match[1])}|${match[2].trim()}`;
+	return normalizeExponent(normalizedSpaces);
+}
+//#endregion
+//#region src/numbers/predicates.ts
+/** Checks whether a value is supported as a finite numeric or fraction input. */
+function isNumeric(value) {
+	if (value === void 0 || value === null || Array.isArray(value) || typeof value === "object" || Number.isNaN(value) || value === "NaN" || value === Infinity || value === -Infinity || value === "Infinity" || value === "-Infinity") return false;
+	if (isFraction(value)) return true;
+	return typeof value === "string" ? !isNaN(parseFloat(value)) && (EXP_NOTATION_RE.test(value) || isFinite(value)) : isFinite(value);
+}
+const isNonNumerical = (value) => {
+	return !isNumeric(value);
+};
+const isPercentage = (value) => {
+	return typeof value === "string" && /^\d+(\.\d+)?%$/.test(value);
+};
+function allNumbers(values) {
+	return !values.some((value) => typeof value !== "number");
+}
+//#endregion
+//#region src/numbers/parsing/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) : 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/numbers/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/numbers/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.
 *
-* @readonly
-* @enum {Object}
+* - 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 DEPRECATED_UNITS = Object.freeze({
-	"N-m": "Nm",
-	"ft-lbf": "ftlbf",
-	"BTU/hr": "BTU/h",
-	"BTU/(htf*degF)": "BTU/(h*ft*degF)",
-	"BTU/(hft*degF)": "BTU/(h*ft*degF)"
-});
+const 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)
+	});
+};
 /**
-* This list is mapping from legal alternative unit names to our selected unit name
+* Rounds a numeric value to N significant digits (only the decimal part)
 *
-* @readonly
-* @enum {Object}
+* - 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 UNIT_ALIASES = Object.freeze({
-	"lbs/ft": "lb/ft",
-	"lbm/ft": "lb/ft",
-	ftUS: "usft"
-});
+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)
+	});
+};
 /**
-* Intermediate conversions
+* Rounds a number to an appropriate number of digits, based on its size.
 *
-* @readonly
-* @enum {Object}
+* @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 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"
-});
+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)
+	});
+};
 /**
-* List of all known units in application
+* Rounds a number to an appropriate number of digits, based on its size in relation to a range.
 *
-* @readonly
-* @enum {string[]}
+* @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 KNOWN_UNITS = Object.freeze(Array.from(new Set(Object.values(ALT_UNITS).flat())));
-const SPECIAL_NUMBERS_STRING = [
-	NaN,
-	-Infinity,
-	Infinity
-].map((number) => number.toString());
+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))));
+};
 /**
-* Description for the different quantites
-* @readonly
+* 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 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",
-	wellheadGrowthMovement: "Wellhead growth movement",
-	deg: "Degree, a unit of angular measurement",
-	dls: "Dogleg Severity, measure of wellbore curvature changes per unit length",
-	wgrad: "Weight Gradient, change in weight per unit length",
-	entalphy: "Entalphy, total heat content of a system",
-	pressurechange: "Change in pressure over time or between two points",
-	rpm: "Rotations per minute, a measure of the frequency of rotation, specifying the number of full rotations completed in one minute around a fixed axis",
-	sensorAccelerometer: "Strength of gravitational acceleration",
-	sensorMagnetometer: "Strength of magnetic forces at a position"
+const 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/format/display-number.ts
+const DEFAULT_AUTO_SCIENTIFIC_BELOW = 1e-4;
+const DEFAULT_AUTO_SCIENTIFIC_ABOVE = 1e7;
+const NUMBER_FORMAT_OPTIONS = { maximumFractionDigits: 20 };
+const formatEnglishNumber = (value) => {
+	let numberFormat;
+	try {
+		numberFormat = new Intl.NumberFormat("en-US", NUMBER_FORMAT_OPTIONS);
+	} catch {
+		numberFormat = new Intl.NumberFormat(void 0, NUMBER_FORMAT_OPTIONS);
+	}
+	return numberFormat.format(value);
+};
+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 = formatEnglishNumber(toNum(value)).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;
 };
 /**
-* Description for the different units
-* @readonly
+* 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 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"
+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;
+};
+/** @deprecated Use `displayNumber` instead. */
+const formatNumber = (number) => {
+	return displayNumber(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/validate/ajv-validators.ts
@@ -2759,99 +2753,40 @@ 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);
+//#region src/units/validation.ts
+/** Normalizes repeated decimal dots and decimal commas. */
+function checkAndCleanDecimalComma(value) {
+	const repeatedDots = /\.{2,}/;
+	const comma = /,/;
+	if (typeof value === "string") while (repeatedDots.test(value) || comma.test(value)) {
+		value = value.replace(repeatedDots, ".");
+		value = value.replace(comma, ".");
+	}
+	return value;
 }
-/**
-* 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;
+/** Cleans raw numeric input while retaining the unit from the previous value. */
+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}`;
 }
-/**
-* 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;
+/** Validates a numeric or unit-encoded value against the package number schema. */
+function validateNumber(value) {
+	let normalizedValue = value;
+	if (typeof value === "string" && isValueWithUnit(value)) normalizedValue = getValue(value);
+	normalizedValue = checkAndCleanDecimalComma(normalizedValue);
+	if (isNumeric(normalizedValue)) return {
+		valid: numberSchemaValidator(toNum(normalizedValue)),
+		errors: transformErrors(numberSchemaValidator.errors)
+	};
+	return {
+		valid: numberSchemaValidator(normalizedValue),
+		errors: transformErrors(numberSchemaValidator.errors)
+	};
 }
-/**
-* 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
-*/
+//#endregion
+//#region src/units/conversion.ts
+/** Converts a numeric value between compatible units. */
 function to(value, fromUnit, toUnit) {
 	value = checkAndCleanDecimalComma(value);
 	value = normalizeScientific(value);
@@ -2864,8 +2799,8 @@ function to(value, fromUnit, toUnit) {
 	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));
+	const conversion = KNOWN_CONVERSIONS[`${fromUnit}|${toUnit}`];
+	if (conversion) return conversion(toNum(value));
 	if (DEPRECATED_UNITS[fromUnit]) {
 		console.warn(`Unit '${fromUnit}' is deprecated - use '${DEPRECATED_UNITS[fromUnit]}' instead.`);
 		return to(value, DEPRECATED_UNITS[fromUnit], toUnit);
@@ -2876,108 +2811,40 @@ function to(value, fromUnit, 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);
-	}
+	const intermediateFromUnit = INTERMEDIATE_CONVERSIONS[fromUnit];
+	if (intermediateFromUnit) return to(to(value, fromUnit, intermediateFromUnit), intermediateFromUnit, toUnit);
+	const intermediateToUnit = INTERMEDIATE_CONVERSIONS[toUnit];
+	if (toUnit && intermediateToUnit && intermediateToUnit !== toUnit) return to(to(value, fromUnit, intermediateToUnit), intermediateToUnit, 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];
+	throw new Error(`No conversions found: ${value} ${fromUnit} -> ${toUnit}`);
 }
-/**
-* 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}`);
+/** Converts a value with an optional unit suffix to the requested unit. */
+function unum(valueWithUnit, toUnit, fromUnit) {
+	if (valueWithUnit == null || valueWithUnit === "") return 0;
+	if (typeof valueWithUnit === "string" && valueWithUnit.startsWith("NaN") || typeof valueWithUnit === "number" && isNaN(valueWithUnit)) return NaN;
+	const parts = split(cleanNumStr(normalizeScientific(valueWithUnit)).replaceAll("+", ""));
+	if (!parts) {
+		if (toUnit && fromUnit) return unum(valueWithUnit + fromUnit, toUnit);
+		throw new Error(`unum: invalid number: ${valueWithUnit}`);
+	}
+	if (parts[0] == null) parts[0] = "0";
+	if (parts[1]) fromUnit = parts[1];
+	if (!fromUnit && toUnit !== fromUnit) throw new Error(`unum: unable to figure out unit: ${valueWithUnit} 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]);
+		const value = parts[0] ? toNum(parts[0]) : 0;
+		if (value === Infinity || value === "Infinity") return Infinity;
+		if (value === -Infinity || value === "-Infinity") return -Infinity;
+		if (typeof value === "string" && EXP_NOTATION_RE.test(value)) return parseFloat(value);
+		if (!isNumeric(value) && value !== Infinity && value !== -Infinity) throw new Error(`unum: invalid number: ${value}, ${typeof value}`);
+		return cleanNum(value);
+	}
+	return to(parts[0], fromUnit, toUnit);
 }
-/**
-* 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);
+/** Alias for `unum`. */
+function convertAndGetValue(value, toUnit, fromUnit) {
+	return unum(value, 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
-*/
+/** Converts a value while preserving string types and empty values. */
 function convertAndGetValueStrict(value, toUnit, fromUnit) {
 	if (value === "" || value === null) return value;
 	if (typeof value === "string" && isValueWithUnit(value) && getValue(value) === "") return "";
@@ -2985,174 +2852,44 @@ function convertAndGetValueStrict(value, toUnit, fromUnit) {
 	const result = convertAndGetValue(value, toUnit, fromUnit);
 	return isString ? toString(result) : result;
 }
-/**
-* Convert value to the base unit given by the quantity
-*
-* @param value
-* @param quantity
-* @return number
-*/
+/** Converts a value to the base unit configured for a quantity. */
 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("|");
+	const baseUnit = unitFromKey(quantity);
+	return unum(value, baseUnit, split((value || "").toString())[1] || baseUnit);
 }
-/**
-* 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);
+/** Converts a value and appends the requested unit. */
+function unumWithUnit(value, toUnit, fromUnit) {
+	return withUnit(unum(value, 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);
+/** Converts a unit value while retaining approximately the input precision. */
+function convertSamePrecision(valueWithUnit, toUnit, digits) {
+	const validValueWithUnit = String(valueWithUnit);
+	const parts = split(validValueWithUnit);
+	const convertedNumber = !parts[1] || parts[1] == toUnit ? Number(parts[0]) : to(parts[0], String(parts[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;
+			if (parts[1] === toUnit) return validValueWithUnit;
+			const digitParts = String(parts[0]).match(/^[-+.,0]*(\d*)[.,]?(\d*)/);
+			targetDigits = digitParts ? Math.max(3, digitParts[1].length + digitParts[2].length) : 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();
+		const limit = Math.pow(10, --targetDigits);
+		const absoluteNumber = Math.abs(convertedNumber);
+		if (absoluteNumber >= 1e5 * limit || absoluteNumber * 1e4 * (1 + limit) < limit) prettyNumber = convertedNumber.toExponential(targetDigits);
+		else if (absoluteNumber >= limit) 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));
+			const magnitude = Math.floor(Math.log10(absoluteNumber));
+			prettyNumber = convertedNumber.toFixed(targetDigits - magnitude);
+			let index = prettyNumber.length;
+			if (prettyNumber[--index] == "0") {
+				while (prettyNumber[--index] == "0");
+				prettyNumber = prettyNumber.slice(0, index + (prettyNumber[index] == "." ? 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,
@@ -3232,12 +2969,6 @@ Object.defineProperty(exports, "allNumbers", {
 		return allNumbers;
 	}
 });
-Object.defineProperty(exports, "altUnitsList", {
-	enumerable: true,
-	get: function() {
-		return altUnitsList;
-	}
-});
 Object.defineProperty(exports, "asFraction", {
 	enumerable: true,
 	get: function() {
@@ -3286,12 +3017,6 @@ Object.defineProperty(exports, "convertSamePrecision", {
 		return convertSamePrecision;
 	}
 });
-Object.defineProperty(exports, "convertTable", {
-	enumerable: true,
-	get: function() {
-		return convertTable;
-	}
-});
 Object.defineProperty(exports, "displayNumber", {
 	enumerable: true,
 	get: function() {
@@ -3322,12 +3047,6 @@ Object.defineProperty(exports, "getAltUnitsListByQuantity", {
 		return getAltUnitsListByQuantity;
 	}
 });
-Object.defineProperty(exports, "getNumberOfDigitsToShow", {
-	enumerable: true,
-	get: function() {
-		return getNumberOfDigitsToShow;
-	}
-});
 Object.defineProperty(exports, "getQuantities", {
 	enumerable: true,
 	get: function() {
@@ -3454,12 +3173,6 @@ Object.defineProperty(exports, "roundByRange", {
 		return roundByRange;
 	}
 });
-Object.defineProperty(exports, "roundNumberWithLabel", {
-	enumerable: true,
-	get: function() {
-		return roundNumberWithLabel;
-	}
-});
 Object.defineProperty(exports, "roundToDecimalPrecision", {
 	enumerable: true,
 	get: function() {
@@ -3569,4 +3282,4 @@ Object.defineProperty(exports, "withUnit", {
 	}
 });
 
-//# sourceMappingURL=units2.cjs.map
+//# sourceMappingURL=conversion.cjs.map