@oliasoft-open-source/units 5.9.0 → 5.10.0

package/dist/chunks/conversion.cjs

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