@oliasoft-open-source/units 5.9.0 → 5.10.0-beta-1

package/dist/index.cjs

@@ -1,6 +1,2937 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_conversion = require("./chunks/conversion.cjs");
-const require_units = require("./chunks/units.cjs");
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let fraction_js = require("fraction.js");
+fraction_js = __toESM(fraction_js, 1);
+//#region src/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 [
+		initialValue,
+		false,
+		iteration
+	];
+}
+/** 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));
+	};
+	const derivative = (value) => {
+		return -sqrt(2 / Math.PI) * exp(-.5 * value ** 2);
+	};
+	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/units/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",
+	"deg/h": "°/h"
+});
+/**
+* Alternative units grouped by quantity
+*
+* @readonly
+* @enum {Object}
+*/
+const ALT_UNITS = Object.freeze({
+	acceleration: ["ft/s2", "m/s2"],
+	angleGradient: [
+		"deg/30m",
+		"rad/m",
+		"deg/m",
+		"deg/ft",
+		"rad/ft",
+		"deg/100ft",
+		"deg/10m"
+	],
+	angles: ["deg", "rad"],
+	areaOther: [
+		"in2",
+		"ft2",
+		"mm2",
+		"cm2",
+		"m2",
+		"mile2",
+		"km2"
+	],
+	areaTubular: [
+		"in2",
+		"cm2",
+		"ft2",
+		"m2"
+	],
+	blowoutFlowRate: [
+		"lpm",
+		"bpm",
+		"m3/min",
+		"ft3/s",
+		"m3/s",
+		"MMSCFD",
+		"ft3/d",
+		"m3/d",
+		"bbl/d",
+		"Mm3/d",
+		"STB/d",
+		"Sm3/d",
+		"Sm3/min",
+		"MSm3/d",
+		"SCF/d"
+	],
+	blowoutGasFlowRate: [
+		"MMSCFD",
+		"Sm3/d",
+		"MSm3/d",
+		"SCF/d"
+	],
+	blowoutOilFlowRate: [
+		"Sm3/d",
+		"Sm3/min",
+		"STB/d"
+	],
+	deg: ["deg", "rad"],
+	density: [
+		"sg",
+		"ppg",
+		"kg/m3",
+		"lbm/ft3",
+		"g/cm3",
+		"lb/ft3",
+		"kPa/m"
+	],
+	densityGas: [
+		"Gsg",
+		"Gppg",
+		"Gkg/m3",
+		"Glbm/ft3"
+	],
+	densityOil: [
+		"sg",
+		"ppg",
+		"kg/m3",
+		"lbm/ft3"
+	],
+	densityOilGas: [
+		"ppg",
+		"kg/m3",
+		"lbm/ft3"
+	],
+	densitySolid: [
+		"sg",
+		"ppg",
+		"kg/m3",
+		"lbm/ft3"
+	],
+	depth: ["m", "ft"],
+	diameters: [
+		"in",
+		"m",
+		"cm",
+		"ft",
+		"mm"
+	],
+	distance: ["m", "ft"],
+	dls: [
+		"deg/10m",
+		"deg/30m",
+		"deg/100ft"
+	],
+	doglegSeverity: [
+		"deg/10m",
+		"deg/30m",
+		"deg/100ft"
+	],
+	duration: [
+		"s",
+		"h",
+		"d",
+		"min"
+	],
+	durationShort: [
+		"s",
+		"min",
+		"h",
+		"d"
+	],
+	durationLong: [
+		"min",
+		"h",
+		"d",
+		"month",
+		"year"
+	],
+	flowrate: [
+		"lpm",
+		"gpm",
+		"bpm",
+		"ft3/d",
+		"ft3/s",
+		"m3/s",
+		"m3/d",
+		"m3/min",
+		"Mm3/d",
+		"bbl/d",
+		"MMSCFD",
+		"STB/d",
+		"Sm3/d",
+		"Sm3/min",
+		"MSm3/d",
+		"SCF/d"
+	],
+	fluidCompressibility: [
+		"1/bar",
+		"1/psi",
+		"1/Pa",
+		"1/kPa",
+		"1/MPa",
+		"1/GPa"
+	],
+	force: [
+		"tonnes",
+		"lbf",
+		"kgf",
+		"N",
+		"kN",
+		"tonneForce",
+		"klbf"
+	],
+	forceGradient: ["lbf/ft", "N/m"],
+	frequency: ["Hz"],
+	gasVolume: [
+		"MMSCF",
+		"Sm3",
+		"MSm3",
+		"SCF"
+	],
+	gor: ["Sm3/Sm3", "SCF/STB"],
+	height: ["m", "ft"],
+	intensity: [
+		"W/m2",
+		"hhp/in2",
+		"hhp/ft2"
+	],
+	interfacialTension: [
+		"dyn/cm",
+		"N/m",
+		"lbf/ft",
+		"mN/m"
+	],
+	latitude: ["°N", "°S"],
+	length: [
+		"m",
+		"cm",
+		"ft",
+		"km",
+		"in",
+		"mm"
+	],
+	linearCapacity: ["l/m", "bbl/ft"],
+	longitude: ["°E", "°W"],
+	massFlowRate: [
+		"kg/s",
+		"lbm/s",
+		"tonnes/h",
+		"tons/h"
+	],
+	moleWeight: [
+		"kg/mol",
+		"lbf/mol",
+		"g/mol"
+	],
+	oilVolume: ["STB", "Sm3"],
+	percentage: ["%", "fr"],
+	permeability: ["mD", "m2"],
+	power: [
+		"hp",
+		"W",
+		"hhp",
+		"MW",
+		"kW",
+		"BTU/h"
+	],
+	pressure: [
+		"bar",
+		"psi",
+		"Pa",
+		"kPa",
+		"MPa",
+		"ksi",
+		"GPa",
+		"lbf/100ft2"
+	],
+	pressureGradient: [
+		"bar/100m",
+		"Pa/m",
+		"bar/m",
+		"psi/100ft",
+		"psi/ft",
+		"kPa/m"
+	],
+	pressurechange: [
+		"bar",
+		"psi",
+		"Pa",
+		"MPa",
+		"kPa"
+	],
+	gasliftFlowRate: [
+		"STB/d",
+		"Sm3/d",
+		"SCF/d"
+	],
+	productionFlowRate: [
+		"MMSCFD",
+		"STB/d",
+		"Sm3/d",
+		"Sm3/min",
+		"MSm3/d",
+		"SCF/d"
+	],
+	productionFlowRateOil: [
+		"MMSCFD",
+		"STB/d",
+		"Sm3/d",
+		"Sm3/min",
+		"MSm3/d",
+		"SCF/d"
+	],
+	productionFlowRateGas: [
+		"MMSCFD",
+		"STB/d",
+		"Sm3/d",
+		"MSm3/d",
+		"SCF/d"
+	],
+	injectionFlowRate: [
+		"lpm",
+		"lps",
+		"bpm",
+		"gpm",
+		"MMSCFD",
+		"STB/d",
+		"Sm3/d",
+		"Sm3/min",
+		"MSm3/d",
+		"SCF/d"
+	],
+	pumpRate: [
+		"lpm",
+		"lps",
+		"bpm",
+		"m3/s",
+		"Sm3/min",
+		"ft3/s",
+		"gpm"
+	],
+	rotationalSpeed: ["rpm", "Hz"],
+	rotationalRate: ["deg/h"],
+	roughness: [
+		"m",
+		"microM",
+		"in",
+		"mm"
+	],
+	rpm: ["rpm", "Hz"],
+	sdstats: ["CI", "Sigma"],
+	specificHeatCapacity: [
+		"J/(kg*degC)",
+		"J/(kg*degK)",
+		"BTU/(lbm*degF)"
+	],
+	speed: [
+		"km/h",
+		"ft/min",
+		"mph",
+		"ft/h",
+		"ft/s",
+		"m/min",
+		"m/s",
+		"m/h"
+	],
+	inverseStandSpeed: [
+		"d/stand",
+		"h/stand",
+		"min/stand",
+		"s/stand"
+	],
+	rop: [
+		"ft/h",
+		"ft/min",
+		"ft/s",
+		"km/h",
+		"m/h",
+		"m/min",
+		"m/s",
+		"mph"
+	],
+	stress: [
+		"MPa",
+		"kPa",
+		"psi",
+		"bar",
+		"Pa",
+		"ksi",
+		"lbf/100ft2"
+	],
+	temperature: [
+		"C",
+		"F",
+		"K"
+	],
+	pressurePerTemperature: [
+		"Pa/C",
+		"Bar/C",
+		"psi/F",
+		"psi/C"
+	],
+	tempgrad: [
+		"C/100m",
+		"F/100ft",
+		"K/100m",
+		"C/m",
+		"F/ft",
+		"K/m"
+	],
+	thermalConductivity: ["BTU/(h*ft*degF)", "W/(mK)"],
+	thermalExpansionCoefficient: [
+		"E-06/degC",
+		"E-06/degF",
+		"1/K"
+	],
+	torque: [
+		"Nm",
+		"ftlbf",
+		"kNm"
+	],
+	torqueGradient: [
+		"N",
+		"lbf",
+		"tonnes"
+	],
+	turbulentSkin: [
+		"s/m3",
+		"1/m3/d",
+		"1/MMSCFD"
+	],
+	viscosity: [
+		"Pa*s",
+		"P",
+		"mPa*s",
+		"cP"
+	],
+	inflowProductivityIndex: [
+		"Sm3/d/bar",
+		"STB/d/psi",
+		"m3/s/bar"
+	],
+	volume: [
+		"m3",
+		"bbl",
+		"Mm3",
+		"l",
+		"USGal",
+		"ft3",
+		"STB",
+		"Sm3",
+		"MMSCF",
+		"MSm3",
+		"SCF"
+	],
+	kickToleranceVolume: [
+		"m3",
+		"bbl",
+		"USGal",
+		"ft3",
+		"STB",
+		"Sm3",
+		"SCF"
+	],
+	weight: [
+		"tonnes",
+		"kg",
+		"lbf",
+		"mt",
+		"kip",
+		"N"
+	],
+	weightGradient: ["ppf", "kg/m"],
+	wgrad: ["sg", "ppg"],
+	wltubulars: ["ppf", "kg/m"],
+	youngsModulus: ["Pa", "psi"],
+	massPerLength: ["kg/m", "lb/ft"],
+	wearFactor: [
+		"E-09/bar",
+		"E-10/psi",
+		"E-14/pa"
+	],
+	volumeGradient: [
+		"m3/m",
+		"cm3/m",
+		"mm3/m",
+		"ft3/ft",
+		"in3/ft"
+	],
+	shearStress: ["Pa", "lbf/100ft2"],
+	sensorAccelerometer: ["g", "m/s2"],
+	sensorMagnetometer: ["nT", "Gs"],
+	location: [
+		"lk",
+		"ftCla",
+		"lkCla",
+		"ftSe",
+		"ydSe",
+		"chSe",
+		"chSe(T)",
+		"ftGC",
+		"ydInd",
+		"ft",
+		"m",
+		"usft"
+	],
+	mixingRequirements: ["m3/t", "L/100kg"],
+	entalphy: [
+		"J/kg",
+		"kJ/kg",
+		"BTU/lbm"
+	]
+});
+/**
+* Units list
+*
+* @readonly
+* @enum {Object}
+*/
+const UNIT_FROM_KEY = Object.freeze({
+	density: "sg",
+	densityGas: "Gsg",
+	densityOil: "sg",
+	densityOilGas: "kg/m3",
+	densitySolid: "kg/m3",
+	length: "m",
+	roughness: "m",
+	speed: "m/s",
+	diameters: "in",
+	duration: "s",
+	durationShort: "h",
+	durationLong: "d",
+	pressurechange: "bar",
+	pressure: "bar",
+	temperature: "C",
+	tempgrad: "C/100m",
+	volume: "m3",
+	kickToleranceVolume: "m3",
+	weight: "kg",
+	force: "N",
+	wgrad: "sg",
+	wltubulars: "ppf",
+	flowrate: "lpm",
+	permeability: "mD",
+	interfacialTension: "dyn/cm",
+	deg: "deg",
+	dls: "deg/30m",
+	percentage: "%",
+	latitude: "°N",
+	longitude: "°E",
+	torque: "Nm",
+	rpm: "rpm",
+	testSingleUnit: "m",
+	turbulentSkin: "1/m3/d",
+	pressurePerTemperature: "Pa/C",
+	sdstats: "Sigma",
+	acceleration: "m/s2",
+	massFlowRate: "kg/s",
+	angleGradient: "deg/m",
+	viscosity: "Pa*s",
+	weightGradient: "kg/m",
+	intensity: "W/m2",
+	gor: "Sm3/Sm3",
+	inflowProductivityIndex: "Sm3/d/bar",
+	wearFactor: "E-09/psi",
+	location: "m",
+	inverseStandSpeed: "s/stand",
+	mixingRequirements: "m3/t",
+	entalphy: "J/kg",
+	shearStress: "Pa",
+	volumeGradient: "m3/m",
+	sensorAccelerometer: "g",
+	sensorMagnetometer: "Gs",
+	rotationalRate: "deg/h"
+});
+/**
+* Constants to help conversion
+*
+* @readonly
+* @enum {Object}
+*/
+const C = Object.freeze({
+	g: .0980665175317196,
+	ft_to_m: .3048,
+	inch_to_m: .0254,
+	lbf_to_kg: .45359237,
+	kg_to_lbf: 2.20462262184877,
+	ppf_to_kgm: .45359237 / .3048,
+	kg_cm3: .0293984025938081,
+	bar_to_psi: 14.503773773022,
+	bar_to_pascal: 1e5,
+	sg_to_ppg: 8.345404265,
+	bbl_to_m3: .158987294928,
+	USGal_to_m3: .003785411784,
+	kelvin_to_degrees: 273.15,
+	tonnes_to_pascal: 9806.65,
+	therm_exp_coeff: 1242e-8,
+	psi_to_pascal: 6894.757293168361,
+	ft3_to_m3: .028316846592,
+	ft3_to_in3: 1728,
+	day_to_second: 3600 * 24,
+	m3_per_m_to_ft3_per_ft: 10.763910416709722,
+	in3_per_ft_to_m3_per_m: 537633333333e-16,
+	MSm3d_to_m3s: 625 / 54
+});
+/**
+* Conversions list
+*
+* All unit conversion formulas should have a credible source/reference (please add a comment with URL to where you
+* got the formula when adding new units to this package). For example:
+*  - Wikipedia
+*  - https://www.nist.gov/pml/special-publication-811/nist-guide-si-appendix-b-conversion-factors/nist-guide-si-appendix-b8
+*  - https://www.wolframalpha.com/input?i=cubic+meter+to+bbl
+*
+* Do not round conversion factors in formulas (we need full precision). Make sure the inverse conversion (A->B->A)
+* produces a valid result.
+*
+* @readonly
+* @enum {Object}
+*/
+const KNOWN_CONVERSIONS = Object.freeze({
+	"m|mm": (val) => val * 1e3,
+	"m|cm": (val) => val * 100,
+	"m|km": (val) => val / 1e3,
+	"m|ft": (val) => val / C.ft_to_m,
+	"m|in": (val) => val / C.inch_to_m,
+	"m|microM": (val) => val * 1e6,
+	"mm|m": (val) => val / 1e3,
+	"cm|m": (val) => val / 100,
+	"km|m": (val) => val * 1e3,
+	"ft|m": (val) => val * C.ft_to_m,
+	"in|m": (val) => val * C.inch_to_m,
+	"microM|m": (val) => val / 1e6,
+	"m2|mm2": (val) => val * 1e6,
+	"m2|cm2": (val) => val * 1e4,
+	"m2|km2": (val) => val / 1e6,
+	"m2|in2": (val) => val * 1550.0031,
+	"m2|ft2": (val) => val * 10.76391,
+	"m2|mile2": (val) => val * 3.861022e-7,
+	"mm2|m2": (val) => val / 1e6,
+	"cm2|m2": (val) => val / 1e4,
+	"km2|m2": (val) => val * 1e6,
+	"in2|m2": (val) => val / 1550.0031,
+	"ft2|m2": (val) => val / 10.76391,
+	"mile2|m2": (val) => val / 3.861022e-7,
+	"m3|bbl": (val) => val / C.bbl_to_m3,
+	"m3|ft3": (val) => val / C.ft3_to_m3,
+	"m3|l": (val) => val * 1e3,
+	"m3|Mm3": (val) => val / 1e6,
+	"m3|USGal": (val) => val / C.USGal_to_m3,
+	"bbl|m3": (val) => val * C.bbl_to_m3,
+	"ft3|m3": (val) => val * C.ft3_to_m3,
+	"Mm3|m3": (val) => val * 1e6,
+	"l|m3": (val) => val / 1e3,
+	"USGal|m3": (val) => val * C.USGal_to_m3,
+	"m3|Sm3": (val) => val * 1,
+	"m3|STB": (val) => val * 6.289512957422142,
+	"Sm3|m3": (val) => val * 1,
+	"STB|m3": (val) => val * .1589948230919721,
+	"m3|MMSCF": (val) => val * 1e6 / C.ft3_to_m3,
+	"m3|MSm3": (val) => val * 1e-6,
+	"m3|SCF": (val) => val / C.ft3_to_m3,
+	"MMSCF|m3": (val) => val * 1e-6 * C.ft3_to_m3,
+	"MSm3|m3": (val) => val * 1e6,
+	"SCF|m3": (val) => val * C.ft3_to_m3,
+	"kg/m3|sg": (val) => val * .001,
+	"kg/m3|g/cm3": (val) => val * .001,
+	"kg/m3|lbm/ft3": (val) => val / 16.01846337,
+	"kg/m3|lb/ft3": (val) => val / 16.01846337,
+	"kg/m3|ppg": (val) => val * .008345404265,
+	"sg|kg/m3": (val) => val * 1e3,
+	"g/cm3|kg/m3": (val) => val * 1e3,
+	"lbm/ft3|kg/m3": (val) => val * 16.01846337,
+	"lb/ft3|kg/m3": (val) => val * 16.01846337,
+	"ppg|kg/m3": (val) => val / .008345404265,
+	"sg|kPa/m": (val) => val * 9.81,
+	"kPa/m|sg": (val) => val / 9.81,
+	"Gkg/m3|Gsg": (val) => val / 1.225,
+	"Gkg/m3|Glbm/ft3": (val) => val / 16.0176516725,
+	"Gkg/m3|Gppg": (val) => val / 119.8659491193,
+	"Gsg|Gkg/m3": (val) => val * 1.225,
+	"Glbm/ft3|Gkg/m3": (val) => val * 16.0176516725,
+	"Gppg|Gkg/m3": (val) => val * 119.8659491193,
+	"ppf|kg/m": (val) => val * .45359237 / .3048,
+	"kg/m|ppf": (val) => val * 1 / (.45359237 / .3048),
+	"kg/m|lbf/ft": (val) => val / .67196897675131,
+	"lbf/ft|kg/m": (val) => val * .67196897675131,
+	"Pa|psi": (val) => val / C.psi_to_pascal,
+	"psi|Pa": (val) => val * C.psi_to_pascal,
+	"Pa|bar": (val) => val * 1e-5,
+	"Pa|kPa": (val) => val * .001,
+	"Pa|MPa": (val) => val * 1e-6,
+	"Pa|GPa": (val) => val * 1e-9,
+	"bar|Pa": (val) => val * 1e5,
+	"kPa|Pa": (val) => val * 1e3,
+	"MPa|Pa": (val) => val * 1e6,
+	"GPa|Pa": (val) => val * 1e9,
+	"psi|ksi": (val) => val / 1e3,
+	"ksi|psi": (val) => val * 1e3,
+	"psi|lbf/100ft2": (val) => val * 14400,
+	"lbf/100ft2|psi": (val) => val / 14400,
+	"1/psi|1/Pa": (val) => val / C.psi_to_pascal,
+	"1/bar|1/Pa": (val) => val * 1e-5,
+	"1/kPa|1/Pa": (val) => val * .001,
+	"1/MPa|1/Pa": (val) => val * 1e-6,
+	"1/GPa|1/Pa": (val) => val * 1e-9,
+	"1/Pa|1/psi": (val) => val * C.psi_to_pascal,
+	"1/Pa|1/bar": (val) => val * 1e5,
+	"1/Pa|1/kPa": (val) => val * 1e3,
+	"1/Pa|1/MPa": (val) => val * 1e6,
+	"1/Pa|1/GPa": (val) => val * 1e9,
+	"C|F": (val) => val * 1.8 + 32,
+	"F|C": (val) => (val - 32) * 5 / 9,
+	"K|C": (val) => val - C.kelvin_to_degrees,
+	"C|K": (val) => val + C.kelvin_to_degrees,
+	"C/100m|F/100ft": (val) => val * 1.8 * C.ft_to_m,
+	"F/100ft|C/100m": (val) => val * 5 / 9 / C.ft_to_m,
+	"C/100m|C/m": (val) => val / 100,
+	"C/m|C/100m": (val) => val * 100,
+	"C/100m|F/ft": (val) => val * 1.8 / 100 * C.ft_to_m,
+	"F/ft|C/100m": (val) => val * 5 / 9 * 100 / C.ft_to_m,
+	"C/100m|K/m": (val) => val / 100,
+	"K/m|C/100m": (val) => val * 100,
+	"K/100m|C/100m": (val) => val,
+	"C/100m|K/100m": (val) => val,
+	"Pa/C|Bar/C": (val) => val * 1e-5,
+	"Pa/C|psi/F": (val) => val / 1.8 / C.psi_to_pascal,
+	"Pa/C|psi/C": (val) => val / C.psi_to_pascal,
+	"Bar/C|Pa/C": (val) => val * 1e5,
+	"psi/F|Pa/C": (val) => val * 1.8 * C.psi_to_pascal,
+	"psi/C|Pa/C": (val) => val * C.psi_to_pascal,
+	"psi/F|psi/C": (val) => val * 1.8,
+	"psi/C|psi/F": (val) => val / 1.8,
+	"kg|kgf": (val) => val,
+	"kg|lbf": (val) => val * C.kg_to_lbf,
+	"kg|t": (val) => val / 1e3,
+	"kg|tonnes": (val) => val / 1e3,
+	"kg|mt": (val) => val / 1e3,
+	"kg|kip": (val) => val * C.kg_to_lbf * .001,
+	"kgf|kg": (val) => val,
+	"lbf|kg": (val) => val * C.lbf_to_kg,
+	"t|kg": (val) => val * 1e3,
+	"tonnes|kg": (val) => val * 1e3,
+	"mt|kg": (val) => val * 1e3,
+	"kip|kg": (val) => val * 1e3 * C.lbf_to_kg,
+	"tonnes|lbf": (val) => val * 1e3 * C.kg_to_lbf,
+	"lbf|tonnes": (val) => val * C.lbf_to_kg / 1e3,
+	"t|lbf": (val) => val * 1e3 * C.kg_to_lbf,
+	"lbf|t": (val) => val * C.lbf_to_kg / 1e3,
+	"mt|lbf": (val) => val * 1e3 * C.kg_to_lbf,
+	"lbf|mt": (val) => val / (1e3 * C.kg_to_lbf),
+	"kgf|lbf": (val) => val * C.kg_to_lbf,
+	"lbf|kgf": (val) => val * C.lbf_to_kg,
+	"kg|g": (val) => val * 1e3,
+	"g|kg": (val) => val / 1e3,
+	"kgf|t": (val) => val / 1e3,
+	"t|kgf": (val) => val * 1e3,
+	"kgf|tonnes": (val) => val / 1e3,
+	"tonnes|kgf": (val) => val * 1e3,
+	"kg/m|lb/ft": (val) => val * 1.4881639435695537,
+	"lb/ft|kg/m": (val) => val * .6719689751395069,
+	"kg|N": (val) => val * C.g * 100,
+	"N|kg": (val) => val / (C.g * 100),
+	"m/s|km/h": (val) => val * 3.6,
+	"km/h|m/s": (val) => val / 3.6,
+	"m/s|ft/s": (val) => val / C.ft_to_m,
+	"m/s|ft/min": (val) => val * 60 / C.ft_to_m,
+	"m/s|ft/h": (val) => val * 3600 / C.ft_to_m,
+	"m/s|m/min": (val) => val * 60,
+	"m/s|m/h": (val) => val * 3600,
+	"ft/s|m/s": (val) => val * C.ft_to_m,
+	"ft/min|m/s": (val) => val * C.ft_to_m / 60,
+	"ft/h|m/s": (val) => val * C.ft_to_m / 3600,
+	"m/min|m/s": (val) => val / 60,
+	"m/h|m/s": (val) => val / 3600,
+	"m/s|mph": (val) => val * 2.2369362920544,
+	"mph|m/s": (val) => val / 2.2369362920544,
+	"ft/h|ft/d": (val) => val * 24,
+	"ft/d|ft/h": (val) => val / 24,
+	"ft/h|m/h": (val) => val * C.ft_to_m,
+	"m/h|ft/h": (val) => val / C.ft_to_m,
+	"ft/d|m/h": (val) => val * C.ft_to_m / 24,
+	"m/h|ft/d": (val) => val * 24 / C.ft_to_m,
+	"ft/d|m/d": (val) => val * C.ft_to_m,
+	"m/d|ft/d": (val) => val / C.ft_to_m,
+	"m/h|m/d": (val) => val * 24,
+	"m/d|m/h": (val) => val / 24,
+	"l/m|bbl/ft": (val) => val * .0019171343228277056,
+	"bbl/ft|l/m": (val) => val / .0019171343228277056,
+	"m3/s|ft3/s": (val) => val / C.ft3_to_m3,
+	"m3/s|lpm": (val) => val * 6e4,
+	"m3/s|bpm": (val) => val * 377.388646,
+	"m3/s|m3/min": (val) => val * 60,
+	"m3/s|m3/d": (val) => val * C.day_to_second,
+	"m3/s|bbl/d": (val) => val * 543439.6505653338,
+	"m3/s|ft3/d": (val) => val * C.day_to_second / C.ft3_to_m3,
+	"m3/s|gpm": (val) => val * 25e11 / 157725491,
+	"m3/s|MMSCFD": (val) => val / .32774128,
+	"m3/s|STB/d": (val) => val * 0x7a7f6097db00 / 247854343,
+	"m3/s|Sm3/d": (val) => val * C.day_to_second,
+	"m3/s|Sm3/min": (val) => val * 60,
+	"Sm3/min|m3/s": (val) => val / 60,
+	"m3/s|MSm3/d": (val) => val / C.MSm3d_to_m3s,
+	"m3/s|SCF/d": (val) => val * 3051187.2047366146,
+	"ft3/s|m3/s": (val) => val * C.ft3_to_m3,
+	"lpm|m3/s": (val) => val / 6e4,
+	"lps|lpm": (val) => val * 60,
+	"lpm|lps": (val) => val / 60,
+	"bpm|m3/s": (val) => val / 377.388646,
+	"m3/d|m3/s": (val) => val / C.day_to_second,
+	"m3/min|m3/s": (val) => val / 60,
+	"bbl/d|m3/s": (val) => val / C.day_to_second * C.bbl_to_m3,
+	"ft3/d|m3/s": (val) => val / C.day_to_second * C.ft3_to_m3,
+	"ft3/d|m3/d": (val) => val * C.ft3_to_m3,
+	"m3/d|ft3/d": (val) => val / C.ft3_to_m3,
+	"m3/d|ft3/s": (val) => val / C.ft3_to_m3 / C.day_to_second,
+	"gpm|m3/s": (val) => val * 157725491 / 25e11,
+	"MMSCFD|m3/s": (val) => val * .32774128,
+	"Mm3/d|m3/d": (val) => val * 1e6,
+	"m3/d|Mm3/d": (val) => val * 1e-6,
+	"STB/d|m3/s": (val) => val * 184021785986e-17,
+	"Sm3/d|m3/d": (val) => val,
+	"m3/d|Sm3/d": (val) => val,
+	"Sm3/d|m3/s": (val) => val / C.day_to_second,
+	"MSm3/d|Sm3/d": (val) => val * 1e6,
+	"Sm3/d|MSm3/d": (val) => val * 1e-6,
+	"MSm3/d|m3/s": (val) => val * C.MSm3d_to_m3s,
+	"SCF/d|m3/s": (val) => val * 3.2774128e-7,
+	"1/m3/d|1/MMSCFD": (val) => val * 28316.85,
+	"1/MMSCFD|1/m3/d": (val) => val / 28316.85,
+	"s/m3|1/m3/d": (val) => val / 86400,
+	"1/m3/d|s/m3": (val) => val * 86400,
+	"kg/s|lbm/s": (val) => val * 2.20462262,
+	"lbm/s|kg/s": (val) => val / 2.20462262,
+	"kg/s|tonnes/h": (val) => val * 3.6,
+	"tonnes/h|kg/s": (val) => val / 3.6,
+	"kg/s|tons/h": (val) => val * 3.9683207193277967,
+	"tons/h|kg/s": (val) => val * .2519957611111111,
+	"lbm/s|tonnes/h": (val) => val * 1.632932532,
+	"tonnes/h|lbm/s": (val) => val * .612395172735771,
+	"lbm/s|tons/h": (val) => val * 1.8,
+	"tons/h|lbm/s": (val) => val / 1.8,
+	"tonnes/h|tons/h": (val) => val * 1.1023113109243878,
+	"tons/h|tonnes/h": (val) => val * .90718474,
+	"mD|m2": (val) => val * 9869233e-19,
+	"m2|mD": (val) => val / 9869233e-19,
+	"N/m|lbf/ft": (val) => val * .22480894387096 * C.ft_to_m,
+	"lbf/ft|N/m": (val) => val / .22480894387096 / C.ft_to_m,
+	"dyn/cm|mN/m": (val) => val,
+	"mN/m|dyn/cm": (val) => val,
+	"dyn/cm|N/m": (val) => val * .001,
+	"N/m|dyn/cm": (val) => val * 1e3,
+	"mN/m|N/m": (val) => val * .001,
+	"N/m|mN/m": (val) => val * 1e3,
+	"Nm|ftlbf": (val) => val * .737562058700684,
+	"Nm|kNm": (val) => val / 1e3,
+	"kNm|Nm": (val) => val * 1e3,
+	"ftlbf|Nm": (val) => val / .737562058700684,
+	"N|kN": (val) => val * .001,
+	"N|kgf": (val) => val * 2e4 / 196133,
+	"N|lbf": (val) => val * 2e12 / 8896443230521,
+	"kN|lbf": (val) => val * 1e3 * 2e12 / 8896443230521,
+	"N|tonneForce": (val) => val * 20 / 196133,
+	"kN|N": (val) => val / .001,
+	"kgf|N": (val) => val * 196133 / 2e4,
+	"lbf|N": (val) => val * 8896443230521 / 2e12,
+	"lbf|kN": (val) => val * 8896443230521 / (2e12 * 1e3),
+	"lbf|tonneForce": (val) => val * 45359237 / 1e11,
+	"klbf|tonneForce": (val) => val * 45359237 / (1e11 * .001),
+	"tonneForce|N": (val) => val * 196133 / 20,
+	"tonneForce|lbf": (val) => val * 1e11 / 45359237,
+	"tonneForce|klbf": (val) => val * 1e11 / (45359237 * 1e3),
+	"klbf|lbf": (val) => val * 1e3,
+	"lbf|klbf": (val) => val / 1e3,
+	"s|min": (val) => val / 60,
+	"s|h": (val) => val / 3600,
+	"s|d": (val) => val / (24 * 3600),
+	"min|s": (val) => val * 60,
+	"h|s": (val) => val * 3600,
+	"d|s": (val) => val * 24 * 3600,
+	"year|d": (val) => val * 365.25,
+	"d|year": (val) => val / 365.25,
+	"year|month": (val) => val * 12,
+	"month|year": (val) => val / 12,
+	"month|d": (val) => val * 30.4375,
+	"d|month": (val) => val / 30.4375,
+	"s/stand|min/stand": (val) => val / 60,
+	"s/stand|h/stand": (val) => val / 3600,
+	"s/stand|d/stand": (val) => val / 86400,
+	"min/stand|s/stand": (val) => val * 60,
+	"h/stand|s/stand": (val) => val * 3600,
+	"d/stand|s/stand": (val) => val * 86400,
+	"min/stand|h/stand": (val) => val / 60,
+	"min/stand|d/stand": (val) => val / 1440,
+	"h/stand|min/stand": (val) => val * 60,
+	"h/stand|d/stand": (val) => val / 24,
+	"d/stand|min/stand": (val) => val * 1440,
+	"d/stand|h/stand": (val) => val * 24,
+	"%|fr": (val) => val * .01,
+	"fr|%": (val) => val / .01,
+	"deg|rad": (val) => val * Math.PI / 180,
+	"rad|deg": (val) => val * 180 / Math.PI,
+	"W|hp": (val) => val / 745.699872,
+	"hp|W": (val) => val * 745.699872,
+	"W|kW": (val) => val / 1e3,
+	"W|MW": (val) => val / 1e6,
+	"kW|W": (val) => val * 1e3,
+	"MW|W": (val) => val * 1e6,
+	"W|BTU/h": (val) => val * 3.4121416351331,
+	"BTU/h|W": (val) => val / 3.4121416351331,
+	"hhp|hp": (val) => val,
+	"hp|hhp": (val) => val,
+	"°N|°S": (val) => val,
+	"°S|°N": (val) => val,
+	"°W|°E": (val) => val,
+	"°E|°W": (val) => val,
+	"BTU/(Kg*K)|BTU/(lbm*degF)": (val) => val / 4186.798188,
+	"BTU/(lbm*degF)|J/(kg*degC)": (val) => val * 4186.798188,
+	"BTU/(lbm*degF)|BTU/(Kg*K)": (val) => val * 4186.798188,
+	"J/(kg*degK)|J/(kg*degC)": (val) => val,
+	"J/(kg*degC)|BTU/(lbm*degF)": (val) => val / 4186.798188,
+	"J/(kg*degC)|J/(kg*degK)": (val) => val,
+	"J/(kg*degC)|J/(s*m*degK)": (val) => val,
+	"BTU/(h*ft*degF)|W/(mK)": (val) => val * 1.7295772056,
+	"BTU/(h*ft*degF)|J/(s*m*degK)": (val) => val * 1.7295772056,
+	"W/(mK)|BTU/(h*ft*degF)": (val) => val / 1.7295772056,
+	"W/(mK)|J/(s*m*degK)": (val) => val,
+	"W/(m*degK)|J/(s*m*degK)": (val) => val,
+	"W/(m*degK)|BTU/(h*ft*degF)": (val) => val / 1.7295772056,
+	"J/(s*m*degK)|BTU/(h*ft*degF)": (val) => val / 1.7295772056,
+	"J/(s*m*degK)|W/(m*degK)": (val) => val,
+	"J/(s*m*degK)|W/(mK)": (val) => val,
+	"J/(s*m*degK)|J/(kg*degC)": (val) => val,
+	"E-06/degF|E-06/degC": (val) => val * 1.8,
+	"E-06/degC|E-06/degF": (val) => val / 1.8,
+	"E-06/degC|1/K": (val) => val / 1e6,
+	"1/K|E-06/degC": (val) => val * 1e6,
+	"rpm|Hz": (val) => val / 60,
+	"Hz|rpm": (val) => val * 60,
+	"CI|Sigma": (val) => get_k_from_conf_int(val),
+	"Sigma|CI": (val) => get_conf_int_from_k(val),
+	"g/mol|kg/mol": (val) => val / 1e3,
+	"kg/mol|g/mol": (val) => val * 1e3,
+	"lbf/mol|kg/mol": (val) => val / C.kg_to_lbf,
+	"kg/mol|lbf/mol": (val) => val * C.kg_to_lbf,
+	"m/s2|ft/s2": (val) => val / C.ft_to_m,
+	"ft/s2|m/s2": (val) => val * C.ft_to_m,
+	"Pa*s|P": (val) => val * 10,
+	"P|Pa*s": (val) => val / 10,
+	"mPa*s|Pa*s": (val) => val / 1e3,
+	"Pa*s|mPa*s": (val) => val * 1e3,
+	"cP|Pa*s": (val) => val * .001,
+	"Pa*s|cP": (val) => val / .001,
+	"Pa/m|bar/m": (val) => val * 1e-5,
+	"bar/m|Pa/m": (val) => val * 1e5,
+	"Pa/m|kPa/m": (val) => val / 1e3,
+	"kPa/m|Pa/m": (val) => val * 1e3,
+	"Pa/m|bar/100m": (val) => val * .001,
+	"bar/100m|Pa/m": (val) => val * 1e3,
+	"bar/m|bar/100m": (val) => val * 100,
+	"bar/100m|bar/m": (val) => val / 100,
+	"psi/ft|Pa/m": (val) => val * C.psi_to_pascal / C.ft_to_m,
+	"Pa/m|psi/ft": (val) => val / C.psi_to_pascal * C.ft_to_m,
+	"psi/100ft|Pa/m": (val) => val * 68.9475729 / C.ft_to_m,
+	"Pa/m|psi/100ft": (val) => val / 68.9475729 * C.ft_to_m,
+	"deg/30m|deg/100ft": (val) => val * (100 * C.ft_to_m / 30),
+	"deg/100ft|deg/30m": (val) => val / (100 * C.ft_to_m / 30),
+	"deg/30m|deg/m": (val) => val / 30,
+	"deg/m|deg/30m": (val) => val * 30,
+	"deg/100ft|deg/ft": (val) => val / 100,
+	"deg/ft|deg/100ft": (val) => val * 100,
+	"deg/100ft|deg/m": (val) => val / (100 * C.ft_to_m),
+	"deg/m|deg/100ft": (val) => val * (100 * C.ft_to_m),
+	"deg/ft|deg/m": (val) => val / C.ft_to_m,
+	"deg/m|deg/ft": (val) => val * C.ft_to_m,
+	"deg/m|rad/m": (val) => val * Math.PI / 180,
+	"rad/m|deg/m": (val) => val * 180 / Math.PI,
+	"rad/ft|deg/m": (val) => val * 180 / Math.PI / C.ft_to_m,
+	"deg/m|rad/ft": (val) => val * Math.PI / 180 * C.ft_to_m,
+	"deg/10m|deg/100ft": (val) => val * (10 * C.ft_to_m),
+	"deg/100ft|deg/10m": (val) => val / (10 * C.ft_to_m),
+	"deg/10m|deg/m": (val) => val / 10,
+	"deg/m|deg/10m": (val) => val * 10,
+	"deg/30m|deg/10m": (val) => val / 3,
+	"deg/10m|deg/30m": (val) => val * 3,
+	"deg/10m|rad/m": (val) => val * Math.PI / 180 / 10,
+	"rad/m|deg/10m": (val) => val * 180 / Math.PI * 10,
+	"W/m2|hhp/in2": (val) => val * (1 / 745.699872 / 1550.0031),
+	"W/m2|hhp/ft2": (val) => val * (1 / 745.699872 / 10.76391),
+	"hhp/in2|W/m2": (val) => val / (1 / 745.699872 / 1550.0031),
+	"hhp/ft2|W/m2": (val) => val / (1 / 745.699872 / 10.76391),
+	"SCF/STB|Sm3/Sm3": (val) => val * .178099173553719,
+	"Sm3/Sm3|SCF/STB": (val) => val * 5.614849187935035,
+	"Sm3/d/bar|m3/s/bar": (val) => val / 86400,
+	"STB/d/psi|m3/s/bar": (val) => val / 37468.77736,
+	"m3/s/bar|Sm3/d/bar": (val) => val * 86400,
+	"m3/s/bar|STB/d/psi": (val) => val * 37468.77736,
+	"E-10/psi|E-09/bar": (val) => val * 1.450377378,
+	"E-10/psi|E-14/pa": (val) => val * 1.450377378,
+	"E-14/pa|E-10/psi": (val) => val / 1.450377378,
+	"E-09/bar|E-10/psi": (val) => val / 1.450377378,
+	"E-14/pa|1/Pa": (val) => val / Math.pow(10, 14),
+	"E-09/bar|1/bar": (val) => val / Math.pow(10, 9),
+	"E-10/psi|1/psi": (val) => val / Math.pow(10, 10),
+	"1/Pa|E-14/pa": (val) => val * Math.pow(10, 14),
+	"1/bar|E-09/bar": (val) => val * Math.pow(10, 9),
+	"1/psi|E-10/psi": (val) => val * Math.pow(10, 10),
+	"m3/m|cm3/m": (val) => val * 10 ** 6,
+	"m3/m|mm3/m": (val) => val * 10 ** 9,
+	"m3/m|ft3/ft": (val) => val * C.m3_per_m_to_ft3_per_ft,
+	"m3/m|in3/ft": (val) => val * C.m3_per_m_to_ft3_per_ft * C.ft3_to_in3,
+	"cm3/m|m3/m": (val) => val * 1e-6,
+	"cm3/m|mm3/m": (val) => val * 1e3,
+	"cm3/m|ft3/ft": (val) => val * C.m3_per_m_to_ft3_per_ft * 1e-6,
+	"cm3/m|in3/ft": (val) => val * C.m3_per_m_to_ft3_per_ft * 1e-6 * C.ft3_to_in3,
+	"mm3/m|m3/m": (val) => val * 1e-9,
+	"mm3/m|cm3/m": (val) => val * .001,
+	"mm3/m|ft3/ft": (val) => val * C.m3_per_m_to_ft3_per_ft * 1e-9,
+	"mm3/m|in3/ft": (val) => val * C.m3_per_m_to_ft3_per_ft * 1e-9 * C.ft3_to_in3,
+	"ft3/ft|m3/m": (val) => val * .09290304,
+	"ft3/ft|cm3/m": (val) => val * 92903.04,
+	"ft3/ft|mm3/m": (val) => val * 92903040,
+	"ft3/ft|in3/ft": (val) => val * 1728,
+	"in3/ft|m3/m": (val) => val * C.in3_per_ft_to_m3_per_m,
+	"in3/ft|cm3/m": (val) => val * C.in3_per_ft_to_m3_per_m * 1e6,
+	"in3/ft|mm3/m": (val) => val * C.in3_per_ft_to_m3_per_m * 1e9,
+	"in3/ft|ft3/ft": (val) => val / C.ft3_to_in3,
+	"Pa|lbf/100ft2": (val) => val * 2.088543423315013,
+	"lbf/100ft2|Pa": (val) => val * .4788025898033584,
+	"usft|m": (val) => val * .30480060960121924,
+	"lk|m": (val) => val * .201168,
+	"ftCla|m": (val) => val * .3047972651151,
+	"lkCla|m": (val) => val * .2011057269733667,
+	"ftGC|m": (val) => val * .30479971018150875,
+	"ydInd|m": (val) => val * .9143985307444408,
+	"ftSe|m": (val) => val * (12 / 39.370147),
+	"ydSe|m": (val) => val * .9143991154275526,
+	"chSe|m": (val) => val * 20.11676512155263,
+	"chSe(T)|m": (val) => val * 20.116756,
+	"m|usft": (val) => val / .30480060960121924,
+	"m|lk": (val) => val / .201168,
+	"m|ftCla": (val) => val / .3047972651151,
+	"m|lkCla": (val) => val / .2011057269733667,
+	"m|ftGC": (val) => val / .30479971018150875,
+	"m|ydInd": (val) => val / .9143985307444408,
+	"m|ftSe": (val) => val / (12 / 39.370147),
+	"m|ydSe": (val) => val / .9143991154275526,
+	"m|chSe": (val) => val / 20.11676512155263,
+	"m|chSe(T)": (val) => val / 20.116756,
+	"m3/t|L/100kg": (val) => val * 100,
+	"L/100kg|m3/t": (val) => val * .01,
+	"kJ/kg|J/kg": (val) => val * 1e3,
+	"J/kg|kJ/kg": (val) => val / 1e3,
+	"BTU/lbm|J/kg": (val) => val * 2326,
+	"J/kg|BTU/lbm": (val) => val / 2326,
+	"g|m/s2": (val) => val * 9.81,
+	"m/s2|g": (val) => val / 9.81,
+	"Gs|nT": (val) => val * 1e5,
+	"nT|Gs": (val) => val / 1e5
+});
+/**
+* Deprecated units
+*
+* @readonly
+* @enum {Object}
+*/
+const DEPRECATED_UNITS = Object.freeze({
+	"N-m": "Nm",
+	"ft-lbf": "ftlbf",
+	"BTU/hr": "BTU/h",
+	"BTU/(htf*degF)": "BTU/(h*ft*degF)",
+	"BTU/(hft*degF)": "BTU/(h*ft*degF)"
+});
+/**
+* This list is mapping from legal alternative unit names to our selected unit name
+*
+* @readonly
+* @enum {Object}
+*/
+const UNIT_ALIASES = Object.freeze({
+	"lbs/ft": "lb/ft",
+	"lbm/ft": "lb/ft",
+	ftUS: "usft"
+});
+/**
+* Intermediate conversions
+*
+* @readonly
+* @enum {Object}
+*/
+const INTERMEDIATE_CONVERSIONS = Object.freeze({
+	mm: "m",
+	cm: "m",
+	km: "m",
+	ft: "m",
+	in: "m",
+	microM: "m",
+	lbf: "kg",
+	t: "kg",
+	tonnes: "kg",
+	mt: "kg",
+	kip: "kg",
+	kW: "W",
+	MW: "W",
+	hp: "W",
+	hhp: "hp",
+	mm2: "m2",
+	cm2: "m2",
+	km2: "m2",
+	in2: "m2",
+	ft2: "m2",
+	mile2: "m2",
+	bbl: "m3",
+	ft3: "m3",
+	Mm3: "m3",
+	l: "m3",
+	USGal: "m3",
+	Sm3: "m3",
+	STB: "m3",
+	MMSCF: "m3",
+	MSm3: "m3",
+	SCF: "m3",
+	kN: "N",
+	kgf: "N",
+	tonneForce: "N",
+	klbf: "lbf",
+	psi: "Pa",
+	bar: "Pa",
+	kPa: "Pa",
+	MPa: "Pa",
+	ksi: "psi",
+	"lbf/100ft2": "psi",
+	"psi/100ft": "Pa/m",
+	"psi/ft": "Pa/m",
+	"bar/100m": "Pa/m",
+	"bar/m": "Pa/m",
+	"Pa/m": "kPa/m",
+	sg: "kg/m3",
+	"g/cm3": "kg/m3",
+	"lbm/ft3": "kg/m3",
+	"lb/ft3": "kg/m3",
+	ppg: "kg/m3",
+	"kPa/m": "sg",
+	Gsg: "Gkg/m3",
+	Gppg: "Gkg/m3",
+	"Glbm/ft3": "Gkg/m3",
+	"1/psi": "1/Pa",
+	"1/bar": "1/Pa",
+	"1/kPa": "1/Pa",
+	"1/MPa": "1/Pa",
+	"1/GPa": "1/Pa",
+	"ft/s": "m/s",
+	"ft/min": "m/s",
+	"ft/h": "m/s",
+	"m/min": "m/s",
+	"m/h": "m/s",
+	mph: "m/s",
+	"ft3/s": "m3/s",
+	lpm: "m3/s",
+	lps: "lpm",
+	bpm: "m3/s",
+	"m3/d": "m3/s",
+	"bbl/d": "m3/s",
+	"ft3/d": "m3/s",
+	"STB/d": "m3/s",
+	"Sm3/d": "m3/s",
+	"Sm3/min": "m3/s",
+	gpm: "m3/s",
+	MMSCFD: "m3/s",
+	"Mm3/d": "m3/d",
+	"m3/min": "m3/s",
+	"MSm3/d": "m3/s",
+	"lbf/ft": "N/m",
+	min: "s",
+	h: "s",
+	d: "s",
+	month: "d",
+	year: "d",
+	"J/(kg*degK)": "J/(kg*degC)",
+	"BTU/(lbm*degF)": "J/(kg*degC)",
+	"BTU/(Kg*K)": "J/(kg*degC)",
+	"BTU/(h*ft*degF)": "J/(s*m*degK)",
+	"W/(m*degK)": "J/(s*m*degK)",
+	"W/(mK)": "J/(s*m*degK)",
+	K: "C",
+	"C/m": "C/100m",
+	"F/ft": "C/100m",
+	"K/m": "C/100m",
+	"F/100ft": "C/100m",
+	"K/100m": "C/100m",
+	"Bar/C": "Pa/C",
+	"s/m3": "1/m3/d",
+	"1/MMSCFD": "1/m3/d",
+	P: "Pa*s",
+	"mPa*s": "Pa*s",
+	cP: "Pa*s",
+	"hhp/in2": "W/m2",
+	"hhp/ft2": "W/m2",
+	"Sm3/d/bar": "m3/s/bar",
+	"STB/d/psi": "m3/s/bar",
+	"deg/100ft": "deg/m",
+	"deg/30m": "deg/m",
+	"deg/10m": "deg/m",
+	"deg/ft": "deg/m",
+	"rad/ft": "deg/m",
+	"lbf/mol": "kg/mol",
+	"g/mol": "kg/mol",
+	"1/K": "E-06/degC",
+	"E-09/bar": "E-10/psi",
+	"E-14/pa": "E-10/psi",
+	"1/Pa": "E-14/pa",
+	kNm: "Nm",
+	ftlbf: "Nm",
+	lk: "m",
+	ftCla: "m",
+	lkCla: "m",
+	ftSe: "m",
+	ydSe: "m",
+	chSe: "m",
+	"chSe(T)": "m",
+	ftGC: "m",
+	ydInd: "m",
+	"BTU/lbm": "J/kg"
+});
+/**
+* List of all known units in application
+*
+* @readonly
+* @enum {string[]}
+*/
+const KNOWN_UNITS = Object.freeze(Array.from(new Set(Object.values(ALT_UNITS).flat())));
+const SPECIAL_NUMBERS_STRING = [
+	NaN,
+	-Infinity,
+	Infinity
+].map((number) => number.toString());
+/**
+* Description for the different quantites
+* @readonly
+*/
+const QUANTITIES_DESCRIPTION = {
+	density: "Density",
+	length: "Length",
+	duration: "Duration",
+	temperature: "Temperature",
+	tempgrad: "Temperature Gradient",
+	volume: "Volume",
+	weight: "Weight",
+	angles: "Angles",
+	depth: "Depth",
+	distance: "Distances",
+	height: "Height",
+	diameters: "Diameters",
+	doglegSeverity: "Dogleg severity",
+	fluidCompressibility: "Fluid Compressibility",
+	force: "Force",
+	gasVolume: "Gas volume",
+	oilVolume: "Oil volume",
+	moleWeight: "Mole weight",
+	linearCapacity: "Linear Capacity",
+	stress: "Stress",
+	thermalConductivity: "Thermal conductivity",
+	specificHeatCapacity: "Specific heat capacity",
+	thermalExpansionCoefficient: "Thermal expansion coefficient",
+	youngsModulus: "Youngs Modulus",
+	torque: "Torque",
+	areaOther: "Area - Other",
+	areaTubular: "Area - Tubular",
+	pumpRate: "Pump Rate",
+	pressure: "Pressure",
+	blowoutFlowRate: "Flowrate (blowout)",
+	percentage: "Percentage",
+	frequency: "Frequency",
+	torqueGradient: "Torque gradient",
+	pressureGradient: "Pressure gradient",
+	flowrate: "Volumetric flow rate",
+	massFlowRate: "Mass flow rate",
+	angleGradient: "Angle gradient",
+	weightGradient: "Weight gradient",
+	forceGradient: "Force gradient",
+	interfacialTension: "Interfacial tension",
+	acceleration: "Acceleration",
+	viscosity: "Viscosity",
+	power: "Power",
+	intensity: "Power intensity",
+	gasliftFlowRate: "Flowrate (Gas lift)",
+	productionFlowRate: "Flowrate (production)",
+	productionFlowRateOil: "Flowrate for Oil (production)",
+	productionFlowRateGas: "Flowrate for Gas (production)",
+	injectionFlowRate: "Flowrate (injection)",
+	blowoutOilFlowRate: "Flowrate for Oil (blowout)",
+	blowoutGasFlowRate: "Flowrate for Gas (blowout)",
+	gor: "Gas Oil Ratio",
+	rotationalSpeed: "Rotational Speed",
+	densityGas: "Density for gas",
+	inflowProductivityIndex: "Inflow productivity index",
+	latitude: "Latitude",
+	longitude: "Longitude",
+	permeability: "Permeability",
+	sdstats: "Standard deviation",
+	roughness: "Material Roughness",
+	wltubulars: "Tubular weight",
+	speed: "Velocity",
+	inverseStandSpeed: "Inverse Stand velocity",
+	rop: "Rate of Penetration (ROP)",
+	densityOil: "Density for oil",
+	densityOilGas: "Density for oil/gas",
+	kickToleranceVolume: "Volume for kick tolerance",
+	densitySolid: "Density for solid",
+	massPerLength: "Mass Per Length",
+	durationShort: "Duration (TempSim short)",
+	durationLong: "Duration (TempSim long)",
+	wearFactor: "Wear factor",
+	turbulentSkin: "Turbulent skin",
+	pressurePerTemperature: "Pressure per temperature",
+	location: "Location coordinates length",
+	mixingRequirements: "Ratio between water and cement",
+	Entalphy: "Entalphy",
+	shearStress: "Shear Stress, force parallel to surface",
+	volumeGradient: "Rate of Volume change per unit",
+	deg: "Degree, a unit of angular measurement",
+	dls: "Dogleg Severity, measure of wellbore curvature changes per unit length",
+	wgrad: "Weight Gradient, change in weight per unit length",
+	entalphy: "Entalphy, total heat content of a system",
+	pressurechange: "Change in pressure over time or between two points",
+	rpm: "Rotations per minute, a measure of the frequency of rotation, specifying the number of full rotations completed in one minute around a fixed axis",
+	sensorAccelerometer: "Strength of gravitational acceleration",
+	sensorMagnetometer: "Strength of magnetic forces at a position",
+	rotationalRate: "Rotational rate, the speed at which an object rotates around a fixed axis, typically measured in degrees per unit of time"
+};
+/**
+* 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",
+	"deg/h": "Degrees per hour"
+};
+//#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.
+*
+* - 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/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;
+};
+/**
+* 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;
+};
+/** @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
+var import_ucs2length = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	function ucs2length(str) {
+		const len = str.length;
+		let length = 0;
+		let pos = 0;
+		let value;
+		while (pos < len) {
+			length++;
+			value = str.charCodeAt(pos++);
+			if (value >= 55296 && value <= 56319 && pos < len) {
+				value = str.charCodeAt(pos);
+				if ((value & 64512) === 56320) pos++;
+			}
+		}
+		return length;
+	}
+	exports.default = ucs2length;
+	ucs2length.code = "require(\"ajv/dist/runtime/ucs2length\").default";
+})))(), 1);
+import_ucs2length.default.default ?? import_ucs2length.default;
+const numberSchemaValidator = validate15;
+function validate15(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+	validate15.errors = null;
+	let vErrors = null;
+	let errors = 0;
+	if (!(typeof data == "number" && isFinite(data))) {
+		const err0 = {
+			instancePath,
+			schemaPath: "#/type",
+			keyword: "type",
+			params: { type: "number" },
+			message: "must be number"
+		};
+		if (vErrors === null) vErrors = [err0];
+		else vErrors.push(err0);
+		errors++;
+	}
+	if (errors > 0) {
+		const emErrs0 = [];
+		for (const err1 of vErrors) if (err1.keyword !== "errorMessage" && !err1.emUsed && (err1.instancePath === instancePath || err1.instancePath.indexOf(instancePath) === 0 && err1.instancePath[instancePath.length] === "/") && err1.schemaPath.indexOf("#") === 0 && err1.schemaPath[1] === "/") {
+			emErrs0.push(err1);
+			err1.emUsed = true;
+		}
+		if (emErrs0.length) {
+			const err2 = {
+				instancePath,
+				schemaPath: "#/errorMessage",
+				keyword: "errorMessage",
+				params: { errors: emErrs0 },
+				message: "Must be a numerical value"
+			};
+			if (vErrors === null) vErrors = [err2];
+			else vErrors.push(err2);
+			errors++;
+		}
+		const emErrs1 = [];
+		for (const err3 of vErrors) if (!err3.emUsed) emErrs1.push(err3);
+		vErrors = emErrs1;
+		errors = emErrs1.length;
+	}
+	validate15.errors = vErrors;
+	return errors === 0;
+}
+//#endregion
+//#region src/validate/errors-transform.ts
+const transformErrors = (errors) => {
+	return errors?.map(({ message }) => message);
+};
+//#endregion
+//#region src/units/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;
+}
+/** 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}`;
+}
+/** 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)
+	};
+}
+//#endregion
+//#region src/units/conversion.ts
+/** Converts a numeric value between compatible units. */
+function to(value, fromUnit, toUnit) {
+	value = checkAndCleanDecimalComma(value);
+	value = normalizeScientific(value);
+	if (toUnit === "undefined") console.warn("Inconsistent \"to unit\" - debug call to \"Units.to()\"");
+	if (fromUnit === "undefined") {
+		fromUnit = toUnit;
+		console.warn("Inconsistent \"from unit\" - debug call to \"Units.to()\"");
+	}
+	if (fromUnit === toUnit) return toNum(value);
+	if (value === Infinity || value === "Infinity") return Infinity;
+	if (value === -Infinity || value === "-Infinity") return -Infinity;
+	if (isNonNumerical(value) && value !== "") return NaN;
+	const 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);
+	}
+	if (DEPRECATED_UNITS[toUnit]) {
+		console.warn(`Unit '${toUnit}' is deprecated - use '${DEPRECATED_UNITS[toUnit]}' instead.`);
+		return to(value, fromUnit, DEPRECATED_UNITS[toUnit]);
+	}
+	if (UNIT_ALIASES[toUnit]) return to(value, fromUnit, UNIT_ALIASES[toUnit]);
+	if (UNIT_ALIASES[fromUnit]) return to(value, UNIT_ALIASES[fromUnit], toUnit);
+	const 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}`);
+}
+/** 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 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);
+}
+/** Alias for `unum`. */
+function convertAndGetValue(value, toUnit, fromUnit) {
+	return unum(value, toUnit, fromUnit);
+}
+/** 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 "";
+	const isString = typeof value === "string";
+	const result = convertAndGetValue(value, toUnit, fromUnit);
+	return isString ? toString(result) : result;
+}
+/** Converts a value to the base unit configured for a quantity. */
+function toBase(value, quantity) {
+	const baseUnit = unitFromKey(quantity);
+	return unum(value, baseUnit, split((value || "").toString())[1] || baseUnit);
+}
+/** Converts a value and appends the requested unit. */
+function unumWithUnit(value, toUnit, fromUnit) {
+	return withUnit(unum(value, toUnit, fromUnit), 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 (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 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 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);
+}
+//#endregion
+//#region src/units/table-conversion.ts
+/** Converts every numeric column in a table to a requested unit row. */
+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 firstCellParts = firstCell && split(`${firstCell}`);
+	const tableHasUnits = !(firstCellParts && firstCellParts[0] && isNaN(firstCellParts[1])) && isNaN(table[0][0]);
+	let rowIndex = tableHasUnits ? 1 : 0;
+	const fromUnitRow = tableHasUnits ? table[0] : defaultUnitRow;
+	const convertedTable = [toUnitRow];
+	for (; rowIndex < table.length; rowIndex += 1) {
+		const convertedColumns = Array(toUnitRow.length);
+		const row = table[rowIndex];
+		for (let unitIndex = 0; unitIndex < convertedColumns.length; unitIndex += 1) convertedColumns[unitIndex] = toUnitRow[unitIndex] && row[unitIndex] ? unum(row[unitIndex], toUnitRow[unitIndex], fromUnitRow[unitIndex]) : row[unitIndex];
+		convertedTable.push(convertedColumns);
+	}
+	if (removeFinalUnitsRow) convertedTable.shift();
+	return convertedTable;
+}
+//#endregion
+//#region src/units/formatting.ts
+/** Rounds a unit string and replaces the unit key with its display label. */
+function roundNumberWithLabel(value, numberOfDigits = 2) {
+	return displayNumber(round(value, numberOfDigits), { withUnit: true });
+}
+/** Returns a value converted to every unit configured for a quantity. */
+function altUnitsList(value, quantity) {
+	let valueWithUnit = value;
+	if (!getUnit(value)) valueWithUnit = withUnit(value, unitFromQuantity(quantity) ?? "");
+	return (ALT_UNITS[quantity] ?? []).map((unit) => [...split(convertSamePrecision(valueWithUnit, unit)), label(unit)]);
+}
+//#endregion
 //#region src/numbers/rounding/number-digits.ts
 /**
 * Calculates a useful decimal precision for small values used by legacy rounding.
@@ -40,82 +2971,82 @@ const COSMETIC_ROUNDING_DEFAULT_PRECISION = 14;
 * roundCosmetic('9750.000000000004|m') -> '9750|m'
 */
 const roundCosmetic = (value) => {
-	if (require_conversion.isScientificStringNum(value)) return value;
-	return require_conversion.roundToPrecision(value, COSMETIC_ROUNDING_DEFAULT_PRECISION);
+	if (isScientificStringNum(value)) return value;
+	return roundToPrecision(value, COSMETIC_ROUNDING_DEFAULT_PRECISION);
 };
 //#endregion
 //#region src/index.ts
 /* istanbul ignore file */
 //#endregion
-exports.ALT_UNITS = require_conversion.ALT_UNITS;
-exports.DEPRECATED_UNITS = require_conversion.DEPRECATED_UNITS;
-exports.EXP_NOTATION_RE = require_conversion.EXP_NOTATION_RE;
-exports.INTERMEDIATE_CONVERSIONS = require_conversion.INTERMEDIATE_CONVERSIONS;
-exports.KNOWN_CONVERSIONS = require_conversion.KNOWN_CONVERSIONS;
-exports.KNOWN_UNITS = require_conversion.KNOWN_UNITS;
-exports.LABELS = require_conversion.LABELS;
-exports.QUANTITIES_DESCRIPTION = require_conversion.QUANTITIES_DESCRIPTION;
-exports.SEPARATOR = require_conversion.SEPARATOR;
-exports.UNITS_DESCRIPTION = require_conversion.UNITS_DESCRIPTION;
-exports.UNIT_ALIASES = require_conversion.UNIT_ALIASES;
-exports.UNIT_FROM_KEY = require_conversion.UNIT_FROM_KEY;
-exports.allNumbers = require_conversion.allNumbers;
-exports.altUnitsList = require_units.altUnitsList;
-exports.asFraction = require_conversion.asFraction;
-exports.charCount = require_conversion.charCount;
-exports.checkAndCleanDecimalComma = require_conversion.checkAndCleanDecimalComma;
-exports.cleanNum = require_conversion.cleanNum;
-exports.cleanNumStr = require_conversion.cleanNumStr;
-exports.convertAndGetValue = require_conversion.convertAndGetValue;
-exports.convertAndGetValueStrict = require_conversion.convertAndGetValueStrict;
-exports.convertSamePrecision = require_conversion.convertSamePrecision;
-exports.convertTable = require_units.convertTable;
-exports.displayNumber = require_conversion.displayNumber;
-exports.displayNumberToFixed = require_conversion.displayNumberToFixed;
-exports.formatNumber = require_conversion.formatNumber;
-exports.fraction = require_conversion.fraction;
-exports.getAltUnitsListByQuantity = require_conversion.getAltUnitsListByQuantity;
+exports.ALT_UNITS = ALT_UNITS;
+exports.DEPRECATED_UNITS = DEPRECATED_UNITS;
+exports.EXP_NOTATION_RE = EXP_NOTATION_RE;
+exports.INTERMEDIATE_CONVERSIONS = INTERMEDIATE_CONVERSIONS;
+exports.KNOWN_CONVERSIONS = KNOWN_CONVERSIONS;
+exports.KNOWN_UNITS = KNOWN_UNITS;
+exports.LABELS = LABELS;
+exports.QUANTITIES_DESCRIPTION = QUANTITIES_DESCRIPTION;
+exports.SEPARATOR = SEPARATOR;
+exports.UNITS_DESCRIPTION = UNITS_DESCRIPTION;
+exports.UNIT_ALIASES = UNIT_ALIASES;
+exports.UNIT_FROM_KEY = UNIT_FROM_KEY;
+exports.allNumbers = allNumbers;
+exports.altUnitsList = altUnitsList;
+exports.asFraction = asFraction;
+exports.charCount = charCount;
+exports.checkAndCleanDecimalComma = checkAndCleanDecimalComma;
+exports.cleanNum = cleanNum;
+exports.cleanNumStr = cleanNumStr;
+exports.convertAndGetValue = convertAndGetValue;
+exports.convertAndGetValueStrict = convertAndGetValueStrict;
+exports.convertSamePrecision = convertSamePrecision;
+exports.convertTable = convertTable;
+exports.displayNumber = displayNumber;
+exports.displayNumberToFixed = displayNumberToFixed;
+exports.formatNumber = formatNumber;
+exports.fraction = fraction;
+exports.getAltUnitsListByQuantity = getAltUnitsListByQuantity;
 exports.getNumberOfDigitsToShow = getNumberOfDigitsToShow;
-exports.getQuantities = require_conversion.getQuantities;
-exports.getUnit = require_conversion.getUnit;
-exports.getUnitsForQuantity = require_conversion.getUnitsForQuantity;
-exports.getValue = require_conversion.getValue;
-exports.isCloseTo = require_conversion.isCloseTo;
-exports.isCloseToOrGreaterThan = require_conversion.isCloseToOrGreaterThan;
-exports.isCloseToOrLessThan = require_conversion.isCloseToOrLessThan;
-exports.isDeepCloseTo = require_conversion.isDeepCloseTo;
-exports.isEmptyValueWithUnit = require_conversion.isEmptyValueWithUnit;
-exports.isFraction = require_conversion.isFraction;
-exports.isNonNumerical = require_conversion.isNonNumerical;
-exports.isNumeric = require_conversion.isNumeric;
-exports.isScientificStringNum = require_conversion.isScientificStringNum;
-exports.isValidNum = require_conversion.isValidNum;
-exports.isValueWithUnit = require_conversion.isValueWithUnit;
-exports.label = require_conversion.label;
-exports.numFraction = require_conversion.numFraction;
-exports.round = require_conversion.round;
-exports.roundByMagnitude = require_conversion.roundByMagnitude;
-exports.roundByMagnitudeToFixed = require_conversion.roundByMagnitudeToFixed;
-exports.roundByRange = require_conversion.roundByRange;
+exports.getQuantities = getQuantities;
+exports.getUnit = getUnit;
+exports.getUnitsForQuantity = getUnitsForQuantity;
+exports.getValue = getValue;
+exports.isCloseTo = isCloseTo;
+exports.isCloseToOrGreaterThan = isCloseToOrGreaterThan;
+exports.isCloseToOrLessThan = isCloseToOrLessThan;
+exports.isDeepCloseTo = isDeepCloseTo;
+exports.isEmptyValueWithUnit = isEmptyValueWithUnit;
+exports.isFraction = isFraction;
+exports.isNonNumerical = isNonNumerical;
+exports.isNumeric = isNumeric;
+exports.isScientificStringNum = isScientificStringNum;
+exports.isValidNum = isValidNum;
+exports.isValueWithUnit = isValueWithUnit;
+exports.label = label;
+exports.numFraction = numFraction;
+exports.round = round;
+exports.roundByMagnitude = roundByMagnitude;
+exports.roundByMagnitudeToFixed = roundByMagnitudeToFixed;
+exports.roundByRange = roundByRange;
 exports.roundCosmetic = roundCosmetic;
-exports.roundNumberWithLabel = require_units.roundNumberWithLabel;
-exports.roundToDecimalPrecision = require_conversion.roundToDecimalPrecision;
-exports.roundToFixed = require_conversion.roundToFixed;
-exports.roundToPrecision = require_conversion.roundToPrecision;
-exports.showAltUnitsList = require_conversion.showAltUnitsList;
-exports.split = require_conversion.split;
-exports.stripLeadingZeros = require_conversion.stripLeadingZeros;
-exports.to = require_conversion.to;
-exports.toBase = require_conversion.toBase;
-exports.toNum = require_conversion.toNum;
-exports.toString = require_conversion.toString;
-exports.unitFromKey = require_conversion.unitFromKey;
-exports.unitFromQuantity = require_conversion.unitFromQuantity;
-exports.unum = require_conversion.unum;
-exports.unumWithUnit = require_conversion.unumWithUnit;
-exports.validateAndClean = require_conversion.validateAndClean;
-exports.validateNumber = require_conversion.validateNumber;
-exports.withPrettyUnitLabel = require_conversion.withPrettyUnitLabel;
-exports.withUnit = require_conversion.withUnit;
+exports.roundNumberWithLabel = roundNumberWithLabel;
+exports.roundToDecimalPrecision = roundToDecimalPrecision;
+exports.roundToFixed = roundToFixed;
+exports.roundToPrecision = roundToPrecision;
+exports.showAltUnitsList = showAltUnitsList;
+exports.split = split;
+exports.stripLeadingZeros = stripLeadingZeros;
+exports.to = to;
+exports.toBase = toBase;
+exports.toNum = toNum;
+exports.toString = toString;
+exports.unitFromKey = unitFromKey;
+exports.unitFromQuantity = unitFromQuantity;
+exports.unum = unum;
+exports.unumWithUnit = unumWithUnit;
+exports.validateAndClean = validateAndClean;
+exports.validateNumber = validateNumber;
+exports.withPrettyUnitLabel = withPrettyUnitLabel;
+exports.withUnit = withUnit;
 
 //# sourceMappingURL=index.cjs.map