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

package/dist/chunks/units.d.cts

@@ -0,0 +1,47 @@
+import { r as ValidateReturn, t as AltUnitWithLabel } from "./types.cjs";
+
+//#region src/units/unit-catalog.d.ts
+declare function showAltUnitsList(quantityKey: string): string[] | undefined;
+declare function getUnitsForQuantity(quantity: string): string[] | undefined;
+declare function getQuantities(): string[] | undefined;
+declare function label(unitKey: string): string | undefined;
+declare function unitFromKey(quantity: string): string | undefined;
+declare function unitFromQuantity(quantity: string): string | undefined;
+declare function getAltUnitsListByQuantity(quantity: string): AltUnitWithLabel[] | undefined;
+//#endregion
+//#region src/units/unit-string.d.ts
+declare const SEPARATOR = "|";
+declare function isEmptyValueWithUnit(value: string | number): boolean;
+declare function split(valueWithUnit: string): string[];
+declare function getValue(valueWithUnit: string): string;
+declare function getUnit(valueWithUnit: string): string;
+declare function isValueWithUnit(value: string | number): boolean;
+declare function withUnit(value: string | number | null | undefined, unit: string | null, defaultValue?: string): string;
+declare function withPrettyUnitLabel(valueWithUnits: string): string;
+//#endregion
+//#region src/units/conversion.d.ts
+declare function to(value: string | number, fromUnit: string, toUnit: string): number;
+declare function unum(valueWithUnit: string | number, toUnit: string, fromUnit?: string): number;
+declare function convertAndGetValue(value: string | number, toUnit: string, fromUnit?: string): number;
+declare function convertAndGetValueStrict(value: string | number | null, toUnit: string, fromUnit?: string): string | number | null;
+declare function toBase(value: string, quantity: string): number;
+declare function unumWithUnit(value: string | number, toUnit: string, fromUnit?: string): string;
+declare function convertSamePrecision(valueWithUnit: string | number, toUnit: string, digits?: number): string;
+//#endregion
+//#region src/units/table-conversion.d.ts
+declare function convertTable(toUnitRow: any, table: any, defaultUnitRow?: [], removeFinalUnitsRow?: boolean): string | number[][];
+//#endregion
+//#region src/units/formatting.d.ts
+declare function roundNumberWithLabel(value: string, numberOfDigits?: number): string;
+declare function altUnitsList(value: string, quantity: string): (string | undefined)[][];
+//#endregion
+//#region src/units/validation.d.ts
+declare function checkAndCleanDecimalComma(value: string | number): string | number;
+declare function validateAndClean(previousValue: string, nextText: string): string;
+declare function validateNumber(value: string | number): ValidateReturn;
+//#endregion
+//#region src/numbers/scientific-notation/scientific-notation.d.ts
+declare const EXP_NOTATION_RE: RegExp;
+//#endregion
+export { getAltUnitsListByQuantity as C, showAltUnitsList as D, label as E, unitFromKey as O, withUnit as S, getUnitsForQuantity as T, getValue as _, altUnitsList as a, split as b, convertAndGetValue as c, to as d, toBase as f, getUnit as g, SEPARATOR as h, validateNumber as i, unitFromQuantity as k, convertAndGetValueStrict as l, unumWithUnit as m, checkAndCleanDecimalComma as n, roundNumberWithLabel as o, unum as p, validateAndClean as r, convertTable as s, EXP_NOTATION_RE as t, convertSamePrecision as u, isEmptyValueWithUnit as v, getQuantities as w, withPrettyUnitLabel as x, isValueWithUnit as y };
+//# sourceMappingURL=units.d.cts.map

package/dist/chunks/units.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"units.d.cts","names":[],"sources":["../../src/units/unit-catalog.ts","../../src/units/unit-string.ts","../../src/units/conversion.ts","../../src/units/table-conversion.ts","../../src/units/formatting.ts","../../src/units/validation.ts","../../src/numbers/scientific-notation/scientific-notation.ts"],"mappings":";;;iBAIgB,gBAAA,CAAiB,WAAA;AAAA,iBAKjB,mBAAA,CAAoB,QAAA;AAAA,iBAKpB,aAAA,CAAA;AAAA,iBAKA,KAAA,CAAM,OAAA;AAAA,iBAKN,WAAA,CAAY,QAAA;AAAA,iBAKZ,gBAAA,CAAiB,QAAA;AAAA,iBAKjB,yBAAA,CAA0B,QAAA,WAAmB,gBAAA;;;cC/BhD,SAAA;AAAA,iBAKG,oBAAA,CAAqB,KAAA;AAAA,iBAKrB,KAAA,CAAM,aAAA;AAAA,iBA2BN,QAAA,CAAS,aAAA;AAAA,iBAKT,OAAA,CAAQ,aAAA;AAAA,iBAKR,eAAA,CAAgB,KAAA;AAAA,iBAShB,QAAA,CAAS,KAAA,sCAA2C,IAAA,iBAAqB,YAAA;AAAA,iBAezE,mBAAA,CAAoB,cAAA;;;iBChEpB,EAAA,CAAG,KAAA,mBAAwB,QAAA,UAAkB,MAAA;AAAA,iBA+D7C,IAAA,CAAK,aAAA,mBAAgC,MAAA,UAAgB,QAAA;AAAA,iBAoDrD,kBAAA,CAAmB,KAAA,mBAAwB,MAAA,UAAgB,QAAA;AAAA,iBAK3D,wBAAA,CACd,KAAA,0BACA,MAAA,UACA,QAAA;AAAA,iBAcc,MAAA,CAAO,KAAA,UAAe,QAAA;AAAA,iBAOtB,YAAA,CAAa,KAAA,mBAAwB,MAAA,UAAgB,QAAA;AAAA,iBAKrD,oBAAA,CAAqB,aAAA,mBAAgC,MAAA,UAAgB,MAAA;;;iBC3JrE,YAAA,CACd,SAAA,OACA,KAAA,OACA,cAAA,OACA,mBAAA;;;iBCAc,oBAAA,CAAqB,KAAA,UAAe,cAAA;AAAA,iBAKpC,YAAA,CAAa,KAAA,UAAe,QAAA;;;iBCL5B,yBAAA,CAA0B,KAAA;AAAA,iBAa1B,gBAAA,CAAiB,aAAA,UAAuB,QAAA;AAAA,iBAuBxC,cAAA,CAAe,KAAA,oBAAyB,cAAA;;;cC1C3C,eAAA,EAAe,MAAA"}

package/dist/chunks/units.d.ts

@@ -0,0 +1,47 @@
+import { r as ValidateReturn, t as AltUnitWithLabel } from "./types.js";
+
+//#region src/units/unit-catalog.d.ts
+declare function showAltUnitsList(quantityKey: string): string[] | undefined;
+declare function getUnitsForQuantity(quantity: string): string[] | undefined;
+declare function getQuantities(): string[] | undefined;
+declare function label(unitKey: string): string | undefined;
+declare function unitFromKey(quantity: string): string | undefined;
+declare function unitFromQuantity(quantity: string): string | undefined;
+declare function getAltUnitsListByQuantity(quantity: string): AltUnitWithLabel[] | undefined;
+//#endregion
+//#region src/units/unit-string.d.ts
+declare const SEPARATOR = "|";
+declare function isEmptyValueWithUnit(value: string | number): boolean;
+declare function split(valueWithUnit: string): string[];
+declare function getValue(valueWithUnit: string): string;
+declare function getUnit(valueWithUnit: string): string;
+declare function isValueWithUnit(value: string | number): boolean;
+declare function withUnit(value: string | number | null | undefined, unit: string | null, defaultValue?: string): string;
+declare function withPrettyUnitLabel(valueWithUnits: string): string;
+//#endregion
+//#region src/units/conversion.d.ts
+declare function to(value: string | number, fromUnit: string, toUnit: string): number;
+declare function unum(valueWithUnit: string | number, toUnit: string, fromUnit?: string): number;
+declare function convertAndGetValue(value: string | number, toUnit: string, fromUnit?: string): number;
+declare function convertAndGetValueStrict(value: string | number | null, toUnit: string, fromUnit?: string): string | number | null;
+declare function toBase(value: string, quantity: string): number;
+declare function unumWithUnit(value: string | number, toUnit: string, fromUnit?: string): string;
+declare function convertSamePrecision(valueWithUnit: string | number, toUnit: string, digits?: number): string;
+//#endregion
+//#region src/units/table-conversion.d.ts
+declare function convertTable(toUnitRow: any, table: any, defaultUnitRow?: [], removeFinalUnitsRow?: boolean): string | number[][];
+//#endregion
+//#region src/units/formatting.d.ts
+declare function roundNumberWithLabel(value: string, numberOfDigits?: number): string;
+declare function altUnitsList(value: string, quantity: string): (string | undefined)[][];
+//#endregion
+//#region src/units/validation.d.ts
+declare function checkAndCleanDecimalComma(value: string | number): string | number;
+declare function validateAndClean(previousValue: string, nextText: string): string;
+declare function validateNumber(value: string | number): ValidateReturn;
+//#endregion
+//#region src/numbers/scientific-notation/scientific-notation.d.ts
+declare const EXP_NOTATION_RE: RegExp;
+//#endregion
+export { getAltUnitsListByQuantity as C, showAltUnitsList as D, label as E, unitFromKey as O, withUnit as S, getUnitsForQuantity as T, getValue as _, altUnitsList as a, split as b, convertAndGetValue as c, to as d, toBase as f, getUnit as g, SEPARATOR as h, validateNumber as i, unitFromQuantity as k, convertAndGetValueStrict as l, unumWithUnit as m, checkAndCleanDecimalComma as n, roundNumberWithLabel as o, unum as p, validateAndClean as r, convertTable as s, EXP_NOTATION_RE as t, convertSamePrecision as u, isEmptyValueWithUnit as v, getQuantities as w, withPrettyUnitLabel as x, isValueWithUnit as y };
+//# sourceMappingURL=units.d.ts.map

package/dist/chunks/units.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"units.d.ts","names":[],"sources":["../../src/units/unit-catalog.ts","../../src/units/unit-string.ts","../../src/units/conversion.ts","../../src/units/table-conversion.ts","../../src/units/formatting.ts","../../src/units/validation.ts","../../src/numbers/scientific-notation/scientific-notation.ts"],"mappings":";;;iBAIgB,gBAAA,CAAiB,WAAA;AAAA,iBAKjB,mBAAA,CAAoB,QAAA;AAAA,iBAKpB,aAAA,CAAA;AAAA,iBAKA,KAAA,CAAM,OAAA;AAAA,iBAKN,WAAA,CAAY,QAAA;AAAA,iBAKZ,gBAAA,CAAiB,QAAA;AAAA,iBAKjB,yBAAA,CAA0B,QAAA,WAAmB,gBAAA;;;cC/BhD,SAAA;AAAA,iBAKG,oBAAA,CAAqB,KAAA;AAAA,iBAKrB,KAAA,CAAM,aAAA;AAAA,iBA2BN,QAAA,CAAS,aAAA;AAAA,iBAKT,OAAA,CAAQ,aAAA;AAAA,iBAKR,eAAA,CAAgB,KAAA;AAAA,iBAShB,QAAA,CAAS,KAAA,sCAA2C,IAAA,iBAAqB,YAAA;AAAA,iBAezE,mBAAA,CAAoB,cAAA;;;iBChEpB,EAAA,CAAG,KAAA,mBAAwB,QAAA,UAAkB,MAAA;AAAA,iBA+D7C,IAAA,CAAK,aAAA,mBAAgC,MAAA,UAAgB,QAAA;AAAA,iBAoDrD,kBAAA,CAAmB,KAAA,mBAAwB,MAAA,UAAgB,QAAA;AAAA,iBAK3D,wBAAA,CACd,KAAA,0BACA,MAAA,UACA,QAAA;AAAA,iBAcc,MAAA,CAAO,KAAA,UAAe,QAAA;AAAA,iBAOtB,YAAA,CAAa,KAAA,mBAAwB,MAAA,UAAgB,QAAA;AAAA,iBAKrD,oBAAA,CAAqB,aAAA,mBAAgC,MAAA,UAAgB,MAAA;;;iBC3JrE,YAAA,CACd,SAAA,OACA,KAAA,OACA,cAAA,OACA,mBAAA;;;iBCAc,oBAAA,CAAqB,KAAA,UAAe,cAAA;AAAA,iBAKpC,YAAA,CAAa,KAAA,UAAe,QAAA;;;iBCL5B,yBAAA,CAA0B,KAAA;AAAA,iBAa1B,gBAAA,CAAiB,aAAA,UAAuB,QAAA;AAAA,iBAuBxC,cAAA,CAAe,KAAA,oBAAyB,cAAA;;;cC1C3C,eAAA,EAAe,MAAA"}

package/dist/chunks/units.js

@@ -0,0 +1,38 @@
+import { H as split, Q as label, R as getUnit, W as withUnit, h as displayNumber, nt as ALT_UNITS, o as unum, r as convertSamePrecision, tt as unitFromQuantity, v as round } from "./conversion.js";
+//#region src/units/table-conversion.ts
+/** Converts every numeric column in a table to a requested unit row. */
+function convertTable(toUnitRow, table, defaultUnitRow, removeFinalUnitsRow = false) {
+	if (!table || !table.length || !table[0].length) return table;
+	if (!toUnitRow) toUnitRow = table[0];
+	if (!defaultUnitRow) defaultUnitRow = toUnitRow;
+	const firstCell = table[0][0];
+	const firstCellParts = firstCell && split(`${firstCell}`);
+	const tableHasUnits = !(firstCellParts && firstCellParts[0] && isNaN(firstCellParts[1])) && isNaN(table[0][0]);
+	let rowIndex = tableHasUnits ? 1 : 0;
+	const fromUnitRow = tableHasUnits ? table[0] : defaultUnitRow;
+	const convertedTable = [toUnitRow];
+	for (; rowIndex < table.length; rowIndex += 1) {
+		const convertedColumns = Array(toUnitRow.length);
+		const row = table[rowIndex];
+		for (let unitIndex = 0; unitIndex < convertedColumns.length; unitIndex += 1) convertedColumns[unitIndex] = toUnitRow[unitIndex] && row[unitIndex] ? unum(row[unitIndex], toUnitRow[unitIndex], fromUnitRow[unitIndex]) : row[unitIndex];
+		convertedTable.push(convertedColumns);
+	}
+	if (removeFinalUnitsRow) convertedTable.shift();
+	return convertedTable;
+}
+//#endregion
+//#region src/units/formatting.ts
+/** Rounds a unit string and replaces the unit key with its display label. */
+function roundNumberWithLabel(value, numberOfDigits = 2) {
+	return displayNumber(round(value, numberOfDigits), { withUnit: true });
+}
+/** Returns a value converted to every unit configured for a quantity. */
+function altUnitsList(value, quantity) {
+	let valueWithUnit = value;
+	if (!getUnit(value)) valueWithUnit = withUnit(value, unitFromQuantity(quantity) ?? "");
+	return (ALT_UNITS[quantity] ?? []).map((unit) => [...split(convertSamePrecision(valueWithUnit, unit)), label(unit)]);
+}
+//#endregion
+export { roundNumberWithLabel as n, convertTable as r, altUnitsList as t };
+
+//# sourceMappingURL=units.js.map

package/dist/chunks/units.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"units.js","names":[],"sources":["../../src/units/table-conversion.ts","../../src/units/formatting.ts"],"sourcesContent":["import { unum } from './conversion.ts';\nimport { split } from './unit-string.ts';\n\n/** Converts every numeric column in a table to a requested unit row. */\nexport function convertTable(\n  toUnitRow: any,\n  table: any,\n  defaultUnitRow?: [],\n  removeFinalUnitsRow = false,\n): string | number[][] {\n  if (!table || !table.length || !table[0].length) {\n    return table;\n  }\n  if (!toUnitRow) {\n    toUnitRow = table[0];\n  }\n  if (!defaultUnitRow) {\n    defaultUnitRow = toUnitRow;\n  }\n\n  const firstCell = table[0][0];\n  const firstCellParts = firstCell && split(`${firstCell}`);\n  const unitNumber = firstCellParts && firstCellParts[0] && isNaN(firstCellParts[1] as unknown as number);\n  const tableHasUnits = !unitNumber && isNaN(table[0][0] as unknown as number);\n  let rowIndex = tableHasUnits ? 1 : 0;\n  const fromUnitRow = tableHasUnits ? table[0] : defaultUnitRow;\n  const convertedTable = [toUnitRow];\n  for (; rowIndex < table.length; rowIndex += 1) {\n    const convertedColumns = Array(toUnitRow.length);\n    const row = table[rowIndex];\n    for (let unitIndex = 0; unitIndex < convertedColumns.length; unitIndex += 1) {\n      convertedColumns[unitIndex] =\n        toUnitRow[unitIndex] && row[unitIndex]\n          ? unum(row[unitIndex], toUnitRow[unitIndex], fromUnitRow[unitIndex] as string)\n          : row[unitIndex];\n    }\n    convertedTable.push(convertedColumns);\n  }\n  if (removeFinalUnitsRow) {\n    convertedTable.shift();\n  }\n  return convertedTable;\n}\n","import { ALT_UNITS } from './constants.ts';\nimport { displayNumber } from '../numbers/format/display-number.ts';\nimport { round } from '../numbers/rounding/rounding.ts';\nimport { convertSamePrecision } from './conversion.ts';\nimport { label, unitFromQuantity } from './unit-catalog.ts';\nimport { getUnit, split, withUnit } from './unit-string.ts';\n\n/** Rounds a unit string and replaces the unit key with its display label. */\nexport function roundNumberWithLabel(value: string, numberOfDigits = 2): string {\n  return displayNumber(round(value, numberOfDigits), { withUnit: true });\n}\n\n/** Returns a value converted to every unit configured for a quantity. */\nexport function altUnitsList(value: string, quantity: string): (string | undefined)[][] {\n  let valueWithUnit = value;\n  if (!getUnit(value)) {\n    valueWithUnit = withUnit(value, unitFromQuantity(quantity) ?? '');\n  }\n  const alternativeUnits = ALT_UNITS[quantity] ?? [];\n  return alternativeUnits.map((unit: string) => [...split(convertSamePrecision(valueWithUnit, unit)), label(unit)]);\n}\n"],"mappings":";;;AAIA,SAAgB,aACd,WACA,OACA,gBACA,sBAAsB,OACD;AACrB,KAAI,CAAC,SAAS,CAAC,MAAM,UAAU,CAAC,MAAM,GAAG,OACvC,QAAO;AAET,KAAI,CAAC,UACH,aAAY,MAAM;AAEpB,KAAI,CAAC,eACH,kBAAiB;CAGnB,MAAM,YAAY,MAAM,GAAG;CAC3B,MAAM,iBAAiB,aAAa,MAAM,GAAG,YAAY;CAEzD,MAAM,gBAAgB,EADH,kBAAkB,eAAe,MAAM,MAAM,eAAe,GAAwB,KAClE,MAAM,MAAM,GAAG,GAAwB;CAC5E,IAAI,WAAW,gBAAgB,IAAI;CACnC,MAAM,cAAc,gBAAgB,MAAM,KAAK;CAC/C,MAAM,iBAAiB,CAAC,UAAU;AAClC,QAAO,WAAW,MAAM,QAAQ,YAAY,GAAG;EAC7C,MAAM,mBAAmB,MAAM,UAAU,OAAO;EAChD,MAAM,MAAM,MAAM;AAClB,OAAK,IAAI,YAAY,GAAG,YAAY,iBAAiB,QAAQ,aAAa,EACxE,kBAAiB,aACf,UAAU,cAAc,IAAI,aACxB,KAAK,IAAI,YAAY,UAAU,YAAY,YAAY,WAAqB,GAC5E,IAAI;AAEZ,iBAAe,KAAK,iBAAiB;;AAEvC,KAAI,oBACF,gBAAe,OAAO;AAExB,QAAO;;;;;ACjCT,SAAgB,qBAAqB,OAAe,iBAAiB,GAAW;AAC9E,QAAO,cAAc,MAAM,OAAO,eAAe,EAAE,EAAE,UAAU,MAAM,CAAC;;;AAIxE,SAAgB,aAAa,OAAe,UAA4C;CACtF,IAAI,gBAAgB;AACpB,KAAI,CAAC,QAAQ,MAAM,CACjB,iBAAgB,SAAS,OAAO,iBAAiB,SAAS,IAAI,GAAG;AAGnE,SADyB,UAAU,aAAa,EAAE,EAC1B,KAAK,SAAiB,CAAC,GAAG,MAAM,qBAAqB,eAAe,KAAK,CAAC,EAAE,MAAM,KAAK,CAAC,CAAC"}

package/dist/index.cjs

@@ -1,6 +1,27 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_units = require("./units2.cjs");
-//#region src/rounding/cosmetic-rounding.ts
+const require_conversion = require("./chunks/conversion.cjs");
+const require_units = require("./chunks/units.cjs");
+//#region src/numbers/rounding/number-digits.ts
+/**
+* Calculates a useful decimal precision for small values used by legacy rounding.
+*
+* @deprecated Use `roundByMagnitude` or another current rounding function instead.
+*/
+function getNumberOfDigitsToShow(value, maxNumberOfDigits = 20) {
+	const defaultDigits = Math.min(4, maxNumberOfDigits);
+	let digits = defaultDigits;
+	if (typeof value !== "number") return defaultDigits;
+	const valueString = String(value);
+	if (/-?[0-9.,]*[Ee]-?[0-9]+/.test(valueString)) {
+		while (Math.abs(value) * 10 ** digits < 1 && digits < maxNumberOfDigits) digits += 1;
+		return Math.min(digits + (defaultDigits - 1), maxNumberOfDigits);
+	}
+	if (value > 1 || value < -1) return defaultDigits;
+	for (let index = 2; index < valueString.length; index += 1) if (valueString[index] !== "0") return Math.min(maxNumberOfDigits, digits + index - 2);
+	return digits;
+}
+//#endregion
+//#region src/numbers/rounding/cosmetic-rounding.ts
 const COSMETIC_ROUNDING_DEFAULT_PRECISION = 14;
 /**
 * Applies display-only rounding to remove floating-point conversion noise.
@@ -19,80 +40,80 @@ const COSMETIC_ROUNDING_DEFAULT_PRECISION = 14;
 * roundCosmetic('9750.000000000004|m') -> '9750|m'
 */
 const roundCosmetic = (value) => {
-	if (require_units.isScientificStringNum(value)) return value;
-	return require_units.roundToPrecision(value, COSMETIC_ROUNDING_DEFAULT_PRECISION);
+	if (require_conversion.isScientificStringNum(value)) return value;
+	return require_conversion.roundToPrecision(value, COSMETIC_ROUNDING_DEFAULT_PRECISION);
 };
 //#endregion
 //#region src/index.ts
 /* istanbul ignore file */
 //#endregion
-exports.ALT_UNITS = require_units.ALT_UNITS;
-exports.DEPRECATED_UNITS = require_units.DEPRECATED_UNITS;
-exports.INTERMEDIATE_CONVERSIONS = require_units.INTERMEDIATE_CONVERSIONS;
-exports.KNOWN_CONVERSIONS = require_units.KNOWN_CONVERSIONS;
-exports.KNOWN_UNITS = require_units.KNOWN_UNITS;
-exports.LABELS = require_units.LABELS;
-exports.QUANTITIES_DESCRIPTION = require_units.QUANTITIES_DESCRIPTION;
-exports.UNITS_DESCRIPTION = require_units.UNITS_DESCRIPTION;
-exports.UNIT_ALIASES = require_units.UNIT_ALIASES;
-exports.UNIT_FROM_KEY = require_units.UNIT_FROM_KEY;
-exports.allNumbers = require_units.allNumbers;
+exports.ALT_UNITS = require_conversion.ALT_UNITS;
+exports.DEPRECATED_UNITS = require_conversion.DEPRECATED_UNITS;
+exports.INTERMEDIATE_CONVERSIONS = require_conversion.INTERMEDIATE_CONVERSIONS;
+exports.KNOWN_CONVERSIONS = require_conversion.KNOWN_CONVERSIONS;
+exports.KNOWN_UNITS = require_conversion.KNOWN_UNITS;
+exports.LABELS = require_conversion.LABELS;
+exports.QUANTITIES_DESCRIPTION = require_conversion.QUANTITIES_DESCRIPTION;
+exports.UNITS_DESCRIPTION = require_conversion.UNITS_DESCRIPTION;
+exports.UNIT_ALIASES = require_conversion.UNIT_ALIASES;
+exports.UNIT_FROM_KEY = require_conversion.UNIT_FROM_KEY;
+exports.allNumbers = require_conversion.allNumbers;
 exports.altUnitsList = require_units.altUnitsList;
-exports.asFraction = require_units.asFraction;
-exports.charCount = require_units.charCount;
-exports.checkAndCleanDecimalComma = require_units.checkAndCleanDecimalComma;
-exports.cleanNum = require_units.cleanNum;
-exports.cleanNumStr = require_units.cleanNumStr;
-exports.convertAndGetValue = require_units.convertAndGetValue;
-exports.convertAndGetValueStrict = require_units.convertAndGetValueStrict;
-exports.convertSamePrecision = require_units.convertSamePrecision;
+exports.asFraction = require_conversion.asFraction;
+exports.charCount = require_conversion.charCount;
+exports.checkAndCleanDecimalComma = require_conversion.checkAndCleanDecimalComma;
+exports.cleanNum = require_conversion.cleanNum;
+exports.cleanNumStr = require_conversion.cleanNumStr;
+exports.convertAndGetValue = require_conversion.convertAndGetValue;
+exports.convertAndGetValueStrict = require_conversion.convertAndGetValueStrict;
+exports.convertSamePrecision = require_conversion.convertSamePrecision;
 exports.convertTable = require_units.convertTable;
-exports.displayNumber = require_units.displayNumber;
-exports.displayNumberToFixed = require_units.displayNumberToFixed;
-exports.formatNumber = require_units.formatNumber;
-exports.fraction = require_units.fraction;
-exports.getAltUnitsListByQuantity = require_units.getAltUnitsListByQuantity;
-exports.getNumberOfDigitsToShow = require_units.getNumberOfDigitsToShow;
-exports.getQuantities = require_units.getQuantities;
-exports.getUnit = require_units.getUnit;
-exports.getUnitsForQuantity = require_units.getUnitsForQuantity;
-exports.getValue = require_units.getValue;
-exports.isCloseTo = require_units.isCloseTo;
-exports.isCloseToOrGreaterThan = require_units.isCloseToOrGreaterThan;
-exports.isCloseToOrLessThan = require_units.isCloseToOrLessThan;
-exports.isDeepCloseTo = require_units.isDeepCloseTo;
-exports.isEmptyValueWithUnit = require_units.isEmptyValueWithUnit;
-exports.isFraction = require_units.isFraction;
-exports.isNonNumerical = require_units.isNonNumerical;
-exports.isNumeric = require_units.isNumeric;
-exports.isScientificStringNum = require_units.isScientificStringNum;
-exports.isValidNum = require_units.isValidNum;
-exports.isValueWithUnit = require_units.isValueWithUnit;
-exports.label = require_units.label;
-exports.numFraction = require_units.numFraction;
-exports.round = require_units.round;
-exports.roundByMagnitude = require_units.roundByMagnitude;
-exports.roundByMagnitudeToFixed = require_units.roundByMagnitudeToFixed;
-exports.roundByRange = require_units.roundByRange;
+exports.displayNumber = require_conversion.displayNumber;
+exports.displayNumberToFixed = require_conversion.displayNumberToFixed;
+exports.formatNumber = require_conversion.formatNumber;
+exports.fraction = require_conversion.fraction;
+exports.getAltUnitsListByQuantity = require_conversion.getAltUnitsListByQuantity;
+exports.getNumberOfDigitsToShow = getNumberOfDigitsToShow;
+exports.getQuantities = require_conversion.getQuantities;
+exports.getUnit = require_conversion.getUnit;
+exports.getUnitsForQuantity = require_conversion.getUnitsForQuantity;
+exports.getValue = require_conversion.getValue;
+exports.isCloseTo = require_conversion.isCloseTo;
+exports.isCloseToOrGreaterThan = require_conversion.isCloseToOrGreaterThan;
+exports.isCloseToOrLessThan = require_conversion.isCloseToOrLessThan;
+exports.isDeepCloseTo = require_conversion.isDeepCloseTo;
+exports.isEmptyValueWithUnit = require_conversion.isEmptyValueWithUnit;
+exports.isFraction = require_conversion.isFraction;
+exports.isNonNumerical = require_conversion.isNonNumerical;
+exports.isNumeric = require_conversion.isNumeric;
+exports.isScientificStringNum = require_conversion.isScientificStringNum;
+exports.isValidNum = require_conversion.isValidNum;
+exports.isValueWithUnit = require_conversion.isValueWithUnit;
+exports.label = require_conversion.label;
+exports.numFraction = require_conversion.numFraction;
+exports.round = require_conversion.round;
+exports.roundByMagnitude = require_conversion.roundByMagnitude;
+exports.roundByMagnitudeToFixed = require_conversion.roundByMagnitudeToFixed;
+exports.roundByRange = require_conversion.roundByRange;
 exports.roundCosmetic = roundCosmetic;
 exports.roundNumberWithLabel = require_units.roundNumberWithLabel;
-exports.roundToDecimalPrecision = require_units.roundToDecimalPrecision;
-exports.roundToFixed = require_units.roundToFixed;
-exports.roundToPrecision = require_units.roundToPrecision;
-exports.showAltUnitsList = require_units.showAltUnitsList;
-exports.split = require_units.split;
-exports.stripLeadingZeros = require_units.stripLeadingZeros;
-exports.to = require_units.to;
-exports.toBase = require_units.toBase;
-exports.toNum = require_units.toNum;
-exports.toString = require_units.toString;
-exports.unitFromKey = require_units.unitFromKey;
-exports.unitFromQuantity = require_units.unitFromQuantity;
-exports.unum = require_units.unum;
-exports.unumWithUnit = require_units.unumWithUnit;
-exports.validateAndClean = require_units.validateAndClean;
-exports.validateNumber = require_units.validateNumber;
-exports.withPrettyUnitLabel = require_units.withPrettyUnitLabel;
-exports.withUnit = require_units.withUnit;
+exports.roundToDecimalPrecision = require_conversion.roundToDecimalPrecision;
+exports.roundToFixed = require_conversion.roundToFixed;
+exports.roundToPrecision = require_conversion.roundToPrecision;
+exports.showAltUnitsList = require_conversion.showAltUnitsList;
+exports.split = require_conversion.split;
+exports.stripLeadingZeros = require_conversion.stripLeadingZeros;
+exports.to = require_conversion.to;
+exports.toBase = require_conversion.toBase;
+exports.toNum = require_conversion.toNum;
+exports.toString = require_conversion.toString;
+exports.unitFromKey = require_conversion.unitFromKey;
+exports.unitFromQuantity = require_conversion.unitFromQuantity;
+exports.unum = require_conversion.unum;
+exports.unumWithUnit = require_conversion.unumWithUnit;
+exports.validateAndClean = require_conversion.validateAndClean;
+exports.validateNumber = require_conversion.validateNumber;
+exports.withPrettyUnitLabel = require_conversion.withPrettyUnitLabel;
+exports.withUnit = require_conversion.withUnit;
 
 //# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":["isScientificStringNum","roundToPrecision"],"sources":["../src/rounding/cosmetic-rounding.ts","../src/index.ts"],"sourcesContent":["import { isScientificStringNum } from '../numbers/numbers.ts';\nimport { roundToPrecision } from './rounding.ts';\n\nconst COSMETIC_ROUNDING_DEFAULT_PRECISION = 14;\n\n/**\n * Applies display-only rounding to remove floating-point conversion noise.\n *\n * The value is rounded to 14 significant digits, while strings written in\n * scientific notation are preserved as entered.\n *\n * - accepts number types, stringified numbers, and unit strings\n * - returns the same type as the input\n *\n * @param value - numeric value to cosmetically round\n * @returns the cosmetically rounded value\n *\n * @example\n * roundCosmetic('9750.000000000004') -> '9750'\n * roundCosmetic('9750.000000000004|m') -> '9750|m'\n */\nexport const roundCosmetic = <Value extends number | string>(value: Value): Value => {\n  if (isScientificStringNum(value)) {\n    return value;\n  }\n\n  return roundToPrecision(value, COSMETIC_ROUNDING_DEFAULT_PRECISION);\n};\n","/* istanbul ignore file */\nimport {\n  label,\n  showAltUnitsList,\n  getAltUnitsListByQuantity,\n  checkAndCleanDecimalComma,\n  unitFromKey,\n  to,\n  split,\n  unum,\n  toBase,\n  altUnitsList,\n  convertTable,\n  roundNumberWithLabel,\n  withUnit,\n  unumWithUnit,\n  validateAndClean,\n  isValueWithUnit,\n  getValue,\n  getUnit,\n  convertSamePrecision,\n  convertAndGetValue,\n  convertAndGetValueStrict,\n  getUnitsForQuantity,\n  getQuantities,\n  unitFromQuantity,\n  withPrettyUnitLabel,\n  validateNumber,\n} from './units.ts';\n\nimport {\n  ALT_UNITS,\n  LABELS,\n  UNIT_FROM_KEY,\n  KNOWN_CONVERSIONS,\n  DEPRECATED_UNITS,\n  UNIT_ALIASES,\n  INTERMEDIATE_CONVERSIONS,\n  KNOWN_UNITS,\n  QUANTITIES_DESCRIPTION,\n  UNITS_DESCRIPTION,\n} from './constants.ts';\n\nimport {\n  isNumeric,\n  isNonNumerical,\n  isEmptyValueWithUnit,\n  allNumbers,\n  formatNumber,\n  charCount,\n  getNumberOfDigitsToShow,\n  fraction,\n  isFraction,\n  asFraction,\n  numFraction,\n  cleanNumStr,\n  cleanNum,\n  stripLeadingZeros,\n} from './utils.ts';\n\nimport { toNum, toString, isValidNum, isScientificStringNum } from './numbers/numbers.ts';\n\nimport { displayNumber, displayNumberToFixed } from './numbers/display-number.ts';\n\nimport {\n  round,\n  roundToFixed,\n  roundToPrecision,\n  roundToDecimalPrecision,\n  roundByMagnitude,\n  roundByMagnitudeToFixed,\n  roundByRange,\n} from './rounding/rounding.ts';\n\nimport { roundCosmetic } from './rounding/cosmetic-rounding.ts';\n\nimport { isCloseTo, isDeepCloseTo, isCloseToOrLessThan, isCloseToOrGreaterThan } from './comparison/comparison.ts';\n\nexport {\n  // Units\n  label,\n  showAltUnitsList,\n  getAltUnitsListByQuantity,\n  getUnitsForQuantity,\n  getQuantities,\n  checkAndCleanDecimalComma,\n  unitFromKey,\n  unitFromQuantity,\n  to,\n  split,\n  unum,\n  toBase,\n  altUnitsList,\n  convertTable,\n  roundNumberWithLabel,\n  withUnit,\n  unumWithUnit,\n  validateAndClean,\n  isValueWithUnit,\n  getValue,\n  getUnit,\n  convertSamePrecision,\n  convertAndGetValue,\n  convertAndGetValueStrict,\n  withPrettyUnitLabel,\n  validateNumber,\n  //Rounding\n  round,\n  roundToFixed,\n  roundToPrecision,\n  roundToDecimalPrecision,\n  roundByMagnitude,\n  roundByMagnitudeToFixed,\n  roundByRange,\n  roundCosmetic,\n  //Comparison\n  isCloseTo,\n  isDeepCloseTo,\n  isCloseToOrLessThan,\n  isCloseToOrGreaterThan,\n  // Utils\n  isNumeric,\n  isNonNumerical,\n  isEmptyValueWithUnit,\n  allNumbers,\n  formatNumber,\n  displayNumber,\n  displayNumberToFixed,\n  charCount,\n  getNumberOfDigitsToShow,\n  fraction,\n  isFraction,\n  asFraction,\n  numFraction,\n  cleanNumStr,\n  cleanNum,\n  toNum,\n  toString,\n  isValidNum,\n  isScientificStringNum,\n  stripLeadingZeros,\n  // Constants\n  ALT_UNITS,\n  LABELS,\n  UNIT_FROM_KEY,\n  KNOWN_CONVERSIONS,\n  DEPRECATED_UNITS,\n  UNIT_ALIASES,\n  INTERMEDIATE_CONVERSIONS,\n  KNOWN_UNITS,\n  QUANTITIES_DESCRIPTION,\n  UNITS_DESCRIPTION,\n};\n"],"mappings":";;;AAGA,MAAM,sCAAsC;;;;;;;;;;;;;;;;;AAkB5C,MAAa,iBAAgD,UAAwB;AACnF,KAAIA,cAAAA,sBAAsB,MAAM,CAC9B,QAAO;AAGT,QAAOC,cAAAA,iBAAiB,OAAO,oCAAoC"}
+{"version":3,"file":"index.cjs","names":["isScientificStringNum","roundToPrecision"],"sources":["../src/numbers/rounding/number-digits.ts","../src/numbers/rounding/cosmetic-rounding.ts","../src/index.ts"],"sourcesContent":["/**\n * Calculates a useful decimal precision for small values used by legacy rounding.\n *\n * @deprecated Use `roundByMagnitude` or another current rounding function instead.\n */\nexport function getNumberOfDigitsToShow(value: number | string, maxNumberOfDigits = 20): number {\n  const defaultDigits = Math.min(4, maxNumberOfDigits);\n  let digits = defaultDigits;\n  if (typeof value !== 'number') {\n    return defaultDigits;\n  }\n\n  const valueString = String(value);\n  const exponentialNumber = /-?[0-9.,]*[Ee]-?[0-9]+/;\n  if (exponentialNumber.test(valueString)) {\n    while (Math.abs(value) * 10 ** digits < 1 && digits < maxNumberOfDigits) {\n      digits += 1;\n    }\n    return Math.min(digits + (defaultDigits - 1), maxNumberOfDigits);\n  }\n\n  if (value > 1 || value < -1) {\n    return defaultDigits;\n  }\n\n  for (let index = 2; index < valueString.length; index += 1) {\n    if (valueString[index] !== '0') {\n      return Math.min(maxNumberOfDigits, digits + index - 2);\n    }\n  }\n  return digits;\n}\n","import { isScientificStringNum } from '../numbers.ts';\nimport { roundToPrecision } from './rounding.ts';\n\nconst COSMETIC_ROUNDING_DEFAULT_PRECISION = 14;\n\n/**\n * Applies display-only rounding to remove floating-point conversion noise.\n *\n * The value is rounded to 14 significant digits, while strings written in\n * scientific notation are preserved as entered.\n *\n * - accepts number types, stringified numbers, and unit strings\n * - returns the same type as the input\n *\n * @param value - numeric value to cosmetically round\n * @returns the cosmetically rounded value\n *\n * @example\n * roundCosmetic('9750.000000000004') -> '9750'\n * roundCosmetic('9750.000000000004|m') -> '9750|m'\n */\nexport const roundCosmetic = <Value extends number | string>(value: Value): Value => {\n  if (isScientificStringNum(value)) {\n    return value;\n  }\n\n  return roundToPrecision(value, COSMETIC_ROUNDING_DEFAULT_PRECISION);\n};\n","/* istanbul ignore file */\nimport {\n  label,\n  showAltUnitsList,\n  getAltUnitsListByQuantity,\n  checkAndCleanDecimalComma,\n  unitFromKey,\n  to,\n  split,\n  unum,\n  toBase,\n  altUnitsList,\n  convertTable,\n  roundNumberWithLabel,\n  withUnit,\n  unumWithUnit,\n  validateAndClean,\n  isValueWithUnit,\n  getValue,\n  getUnit,\n  convertSamePrecision,\n  convertAndGetValue,\n  convertAndGetValueStrict,\n  getUnitsForQuantity,\n  getQuantities,\n  unitFromQuantity,\n  withPrettyUnitLabel,\n  validateNumber,\n} from './units.ts';\nimport { isEmptyValueWithUnit } from './units/unit-string.ts';\n\nimport {\n  ALT_UNITS,\n  LABELS,\n  UNIT_FROM_KEY,\n  KNOWN_CONVERSIONS,\n  DEPRECATED_UNITS,\n  UNIT_ALIASES,\n  INTERMEDIATE_CONVERSIONS,\n  KNOWN_UNITS,\n  QUANTITIES_DESCRIPTION,\n  UNITS_DESCRIPTION,\n} from './units/constants.ts';\n\nimport { asFraction, fraction, isFraction, numFraction } from './numbers/fractions/fractions.ts';\nimport { charCount, cleanNum, cleanNumStr, stripLeadingZeros } from './numbers/parsing/number-input.ts';\nimport { allNumbers, isNonNumerical, isNumeric } from './numbers/predicates.ts';\nimport { getNumberOfDigitsToShow } from './numbers/rounding/number-digits.ts';\n\nimport { toNum, toString, isValidNum, isScientificStringNum } from './numbers/numbers.ts';\n\nimport { displayNumber, displayNumberToFixed, formatNumber } from './numbers/format/display-number.ts';\n\nimport {\n  round,\n  roundToFixed,\n  roundToPrecision,\n  roundToDecimalPrecision,\n  roundByMagnitude,\n  roundByMagnitudeToFixed,\n  roundByRange,\n} from './numbers/rounding/rounding.ts';\n\nimport { roundCosmetic } from './numbers/rounding/cosmetic-rounding.ts';\n\nimport {\n  isCloseTo,\n  isCloseToOrGreaterThan,\n  isCloseToOrLessThan,\n  isDeepCloseTo,\n} from './numbers/comparison/comparison.ts';\n\nexport {\n  // Units\n  label,\n  showAltUnitsList,\n  getAltUnitsListByQuantity,\n  getUnitsForQuantity,\n  getQuantities,\n  checkAndCleanDecimalComma,\n  unitFromKey,\n  unitFromQuantity,\n  to,\n  split,\n  unum,\n  toBase,\n  altUnitsList,\n  convertTable,\n  roundNumberWithLabel,\n  withUnit,\n  unumWithUnit,\n  validateAndClean,\n  isValueWithUnit,\n  getValue,\n  getUnit,\n  convertSamePrecision,\n  convertAndGetValue,\n  convertAndGetValueStrict,\n  withPrettyUnitLabel,\n  validateNumber,\n  //Rounding\n  round,\n  roundToFixed,\n  roundToPrecision,\n  roundToDecimalPrecision,\n  roundByMagnitude,\n  roundByMagnitudeToFixed,\n  roundByRange,\n  roundCosmetic,\n  //Comparison\n  isCloseTo,\n  isDeepCloseTo,\n  isCloseToOrLessThan,\n  isCloseToOrGreaterThan,\n  // Utils\n  isNumeric,\n  isNonNumerical,\n  isEmptyValueWithUnit,\n  allNumbers,\n  formatNumber,\n  displayNumber,\n  displayNumberToFixed,\n  charCount,\n  getNumberOfDigitsToShow,\n  fraction,\n  isFraction,\n  asFraction,\n  numFraction,\n  cleanNumStr,\n  cleanNum,\n  toNum,\n  toString,\n  isValidNum,\n  isScientificStringNum,\n  stripLeadingZeros,\n  // Constants\n  ALT_UNITS,\n  LABELS,\n  UNIT_FROM_KEY,\n  KNOWN_CONVERSIONS,\n  DEPRECATED_UNITS,\n  UNIT_ALIASES,\n  INTERMEDIATE_CONVERSIONS,\n  KNOWN_UNITS,\n  QUANTITIES_DESCRIPTION,\n  UNITS_DESCRIPTION,\n};\n"],"mappings":";;;;;;;;;AAKA,SAAgB,wBAAwB,OAAwB,oBAAoB,IAAY;CAC9F,MAAM,gBAAgB,KAAK,IAAI,GAAG,kBAAkB;CACpD,IAAI,SAAS;AACb,KAAI,OAAO,UAAU,SACnB,QAAO;CAGT,MAAM,cAAc,OAAO,MAAM;AAEjC,KAD0B,yBACJ,KAAK,YAAY,EAAE;AACvC,SAAO,KAAK,IAAI,MAAM,GAAG,MAAM,SAAS,KAAK,SAAS,kBACpD,WAAU;AAEZ,SAAO,KAAK,IAAI,UAAU,gBAAgB,IAAI,kBAAkB;;AAGlE,KAAI,QAAQ,KAAK,QAAQ,GACvB,QAAO;AAGT,MAAK,IAAI,QAAQ,GAAG,QAAQ,YAAY,QAAQ,SAAS,EACvD,KAAI,YAAY,WAAW,IACzB,QAAO,KAAK,IAAI,mBAAmB,SAAS,QAAQ,EAAE;AAG1D,QAAO;;;;AC3BT,MAAM,sCAAsC;;;;;;;;;;;;;;;;;AAkB5C,MAAa,iBAAgD,UAAwB;AACnF,KAAIA,mBAAAA,sBAAsB,MAAM,CAC9B,QAAO;AAGT,QAAOC,mBAAAA,iBAAiB,OAAO,oCAAoC"}

package/dist/index.d.cts

@@ -1,7 +1,7 @@
-import { altUnitsList, checkAndCleanDecimalComma, convertAndGetValue, convertAndGetValueStrict, convertSamePrecision, convertTable, getAltUnitsListByQuantity, getQuantities, getUnit, getUnitsForQuantity, getValue, isValueWithUnit, label, roundNumberWithLabel, showAltUnitsList, split, to, toBase, unitFromKey, unitFromQuantity, unum, unumWithUnit, validateAndClean, validateNumber, withPrettyUnitLabel, withUnit } from "./units.cjs";
+import { C as getAltUnitsListByQuantity, D as showAltUnitsList, E as label, O as unitFromKey, S as withUnit, T as getUnitsForQuantity, _ as getValue, a as altUnitsList, b as split, c as convertAndGetValue, d as to, f as toBase, g as getUnit, i as validateNumber, k as unitFromQuantity, l as convertAndGetValueStrict, m as unumWithUnit, n as checkAndCleanDecimalComma, o as roundNumberWithLabel, p as unum, r as validateAndClean, s as convertTable, u as convertSamePrecision, v as isEmptyValueWithUnit, w as getQuantities, x as withPrettyUnitLabel, y as isValueWithUnit } from "./chunks/units.cjs";
 import { isScientificStringNum, isValidNum, toNum, toString } from "./numbers/numbers.cjs";
 
-//#region src/constants.d.ts
+//#region src/units/constants.d.ts
 declare const LABELS: Record<string, string>;
 declare const ALT_UNITS: Record<string, string[]>;
 declare const UNIT_FROM_KEY: Record<string, string>;
@@ -90,7 +90,6 @@ declare const QUANTITIES_DESCRIPTION: {
   Entalphy: string;
   shearStress: string;
   volumeGradient: string;
-  wellheadGrowthMovement: string;
   deg: string;
   dls: string;
   wgrad: string;
@@ -318,23 +317,27 @@ declare const UNITS_DESCRIPTION: {
   g: string;
 };
 //#endregion
-//#region src/utils.d.ts
-declare function isEmptyValueWithUnit(val: string | number): boolean;
+//#region src/numbers/fractions/fractions.d.ts
 declare const isFraction: (value: unknown) => boolean;
-declare function isNumeric(v: unknown): boolean;
-declare function allNumbers(arr: (number | string)[]): boolean;
-declare const formatNumber: (number: number | string | undefined | null) => string;
-declare function charCount(chr: string | number, str: string): number;
-declare function getNumberOfDigitsToShow(num: number | string, maxNumDigits?: number): number;
-declare function fraction(str: any): number | typeof Infinity | typeof NaN;
-declare function asFraction(str: number | string): string;
-declare function numFraction(str: any): any;
-declare function cleanNumStr(str: string | number): string;
+declare function fraction(value: any): number | typeof Infinity | typeof NaN;
+declare function asFraction(value: number | string): string;
+declare function numFraction(value: any): any;
+//#endregion
+//#region src/numbers/parsing/number-input.d.ts
+declare function charCount(character: string | number, value: string): number;
+declare function cleanNumStr(value: string | number): string;
 declare const stripLeadingZeros: (value: string) => string;
-declare function cleanNum(str: string | number): number;
+declare function cleanNum(value: string | number): number;
+//#endregion
+//#region src/numbers/predicates.d.ts
+declare function isNumeric(value: unknown): boolean;
 declare const isNonNumerical: (value: any) => boolean;
+declare function allNumbers(values: (number | string)[]): boolean;
 //#endregion
-//#region src/numbers/display-number.d.ts
+//#region src/numbers/rounding/number-digits.d.ts
+declare function getNumberOfDigitsToShow(value: number | string, maxNumberOfDigits?: number): number;
+//#endregion
+//#region src/numbers/format/display-number.d.ts
 type NumberDisplayOptions = {
   scientific?: 'auto' | boolean;
   eNotation?: boolean;
@@ -347,8 +350,9 @@ type NumberDisplayOptions = {
 };
 declare const displayNumber: <Value extends number | string | null | undefined>(value: Value, options?: NumberDisplayOptions) => string;
 declare const displayNumberToFixed: <Value extends string | null | undefined>(value: Value, options?: NumberDisplayOptions) => string;
+declare const formatNumber: (number: number | string | undefined | null) => string;
 //#endregion
-//#region src/rounding/rounding.d.ts
+//#region src/numbers/rounding/rounding.d.ts
 declare const round: <Value extends number | string | null | undefined>(value: Value, n?: number) => Value;
 declare const roundToPrecision: <Value extends number | string | null | undefined>(value: Value, n?: number) => Value;
 declare const roundToDecimalPrecision: <Value extends number | string | null | undefined>(value: Value, n?: number) => Value;
@@ -357,10 +361,10 @@ declare const roundByMagnitudeToFixed: <Value extends number | string | null | u
 declare const roundByRange: <Value extends number | string | null | undefined>(value: Value, min: number, max: number, n?: number) => Value;
 declare const roundToFixed: <Value extends number | string | null | undefined>(value: Value, n?: number) => Value;
 //#endregion
-//#region src/rounding/cosmetic-rounding.d.ts
+//#region src/numbers/rounding/cosmetic-rounding.d.ts
 declare const roundCosmetic: <Value extends number | string>(value: Value) => Value;
 //#endregion
-//#region src/comparison/comparison.d.ts
+//#region src/numbers/comparison/comparison.d.ts
 type Without<T, U> = { [P in Exclude<keyof T, keyof U>]?: never };
 type XOR<T, U> = T | U extends Record<string, unknown> ? (Without<T, U> & U) | (Without<U, T> & T) : T | U;
 type toleranceType = XOR<{

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../src/constants.ts","../src/utils.ts","../src/numbers/display-number.ts","../src/rounding/rounding.ts","../src/rounding/cosmetic-rounding.ts","../src/comparison/comparison.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/units/constants.ts","../src/numbers/fractions/fractions.ts","../src/numbers/parsing/number-input.ts","../src/numbers/predicates.ts","../src/numbers/rounding/number-digits.ts","../src/numbers/format/display-number.ts","../src/numbers/rounding/rounding.ts","../src/numbers/rounding/cosmetic-rounding.ts","../src/numbers/comparison/comparison.ts"],"mappings":";;;;cAQa,MAAA,EAAQ,MAAA;AAAA,cAgOR,SAAA,EAAW,MAAA;AAAA,cAgIX,aAAA,EAAe,MAAA;AAAA,cA8Gf,iBAAA,EAAmB,MAAA,UAAgB,GAAA;AAAA,cA0fnC,gBAAA,EAAkB,MAAA;AAAA,cAclB,YAAA,EAAc,MAAA;AAAA,cAYd,wBAAA,EAA0B,MAAA;AAAA,cA0K1B,WAAA;AAAA,cASA,sBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA8FA,iBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCpvCA,UAAA,GAAc,KAAA;AAAA,iBAcX,QAAA,CAAS,KAAA,wBAA6B,QAAA,UAAkB,GAAA;AAAA,iBA2BxD,UAAA,CAAW,KAAA;AAAA,iBAeX,WAAA,CAAY,KAAA;;;iBCzDZ,SAAA,CAAU,SAAA,mBAA4B,KAAA;AAAA,iBAYtC,WAAA,CAAY,KAAA;AAAA,cAwCf,iBAAA,GAAqB,KAAA;AAAA,iBASlB,QAAA,CAAS,KAAA;;;iBC/DT,SAAA,CAAU,KAAA;AAAA,cAwBb,cAAA,GAAkB,KAAA;AAAA,iBAQf,UAAA,CAAW,MAAA;;;iBC/BX,uBAAA,CAAwB,KAAA,mBAAwB,iBAAA;;;KC8B3D,oBAAA;EACH,UAAA;EACA,SAAA;EACA,mBAAA;EACA,mBAAA;EACA,0BAAA;EACA,QAAA;EACA,oBAAA;EACA,gBAAA;AAAA;AAAA,cA6FW,aAAA,qDACX,KAAA,EAAO,KAAA,EACP,OAAA,GAAU,oBAAA;AAAA,cAwCC,oBAAA,4CACX,KAAA,EAAO,KAAA,EACP,OAAA,GAAU,oBAAA;AAAA,cA8BC,YAAA,GAAgB,MAAA;;;cChLhB,KAAA,qDACX,KAAA,EAAO,KAAA,EACP,CAAA,cACC,KAAA;AAAA,cAsFU,gBAAA,qDACX,KAAA,EAAO,KAAA,EACP,CAAA,cACC,KAAA;AAAA,cAmCU,uBAAA,qDACX,KAAA,EAAO,KAAA,EACP,CAAA,cACC,KAAA;AAAA,cA+DU,gBAAA,qDACX,KAAA,EAAO,KAAA,EACP,CAAA,cACC,KAAA;AAAA,cAmCU,uBAAA,qDACX,KAAA,EAAO,KAAA,EACP,CAAA,cACC,KAAA;AAAA,cAuDU,YAAA,qDACX,KAAA,EAAO,KAAA,EACP,GAAA,UACA,GAAA,UACA,CAAA,cACC,KAAA;AAAA,cAgCU,YAAA,qDACX,KAAA,EAAO,KAAA,EACP,CAAA,cACC,KAAA;;;cCtVU,aAAA,kCAAgD,KAAA,EAAO,KAAA,KAAQ,KAAA;;;KCbvE,OAAA,iBAAwB,OAAA,OAAc,CAAA,QAAS,CAAA;AAAA,KAC/C,GAAA,SAAY,CAAA,GAAI,CAAA,SAAU,MAAA,qBAA2B,OAAA,CAAQ,CAAA,EAAG,CAAA,IAAK,CAAA,KAAM,OAAA,CAAQ,CAAA,EAAG,CAAA,IAAK,CAAA,IAAK,CAAA,GAAI,CAAA;AAAA,KAEpG,aAAA,GAAgB,GAAA;EAAM,YAAA;AAAA;EAAmC,YAAA;AAAA;AAAA,cAoCjD,SAAA,GACX,UAAA,0BACA,WAAA,0BACA,OAAA,GAAS,aAAA;AAAA,cA2DE,sBAAA,GACX,UAAA,0BACA,WAAA,0BACA,OAAA,GAAS,aAAA;AAAA,cAiBE,mBAAA,GACX,UAAA,0BACA,WAAA,0BACA,OAAA,GAAS,aAAA;AAAA,cAgBE,aAAA,GACX,CAAA,OACA,CAAA,OACA,OAAA,GAAS,aAAA"}

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-import { altUnitsList, checkAndCleanDecimalComma, convertAndGetValue, convertAndGetValueStrict, convertSamePrecision, convertTable, getAltUnitsListByQuantity, getQuantities, getUnit, getUnitsForQuantity, getValue, isValueWithUnit, label, roundNumberWithLabel, showAltUnitsList, split, to, toBase, unitFromKey, unitFromQuantity, unum, unumWithUnit, validateAndClean, validateNumber, withPrettyUnitLabel, withUnit } from "./units.js";
+import { C as getAltUnitsListByQuantity, D as showAltUnitsList, E as label, O as unitFromKey, S as withUnit, T as getUnitsForQuantity, _ as getValue, a as altUnitsList, b as split, c as convertAndGetValue, d as to, f as toBase, g as getUnit, i as validateNumber, k as unitFromQuantity, l as convertAndGetValueStrict, m as unumWithUnit, n as checkAndCleanDecimalComma, o as roundNumberWithLabel, p as unum, r as validateAndClean, s as convertTable, u as convertSamePrecision, v as isEmptyValueWithUnit, w as getQuantities, x as withPrettyUnitLabel, y as isValueWithUnit } from "./chunks/units.js";
 import { isScientificStringNum, isValidNum, toNum, toString } from "./numbers/numbers.js";
 
-//#region src/constants.d.ts
+//#region src/units/constants.d.ts
 declare const LABELS: Record<string, string>;
 declare const ALT_UNITS: Record<string, string[]>;
 declare const UNIT_FROM_KEY: Record<string, string>;
@@ -90,7 +90,6 @@ declare const QUANTITIES_DESCRIPTION: {
   Entalphy: string;
   shearStress: string;
   volumeGradient: string;
-  wellheadGrowthMovement: string;
   deg: string;
   dls: string;
   wgrad: string;
@@ -318,23 +317,27 @@ declare const UNITS_DESCRIPTION: {
   g: string;
 };
 //#endregion
-//#region src/utils.d.ts
-declare function isEmptyValueWithUnit(val: string | number): boolean;
+//#region src/numbers/fractions/fractions.d.ts
 declare const isFraction: (value: unknown) => boolean;
-declare function isNumeric(v: unknown): boolean;
-declare function allNumbers(arr: (number | string)[]): boolean;
-declare const formatNumber: (number: number | string | undefined | null) => string;
-declare function charCount(chr: string | number, str: string): number;
-declare function getNumberOfDigitsToShow(num: number | string, maxNumDigits?: number): number;
-declare function fraction(str: any): number | typeof Infinity | typeof NaN;
-declare function asFraction(str: number | string): string;
-declare function numFraction(str: any): any;
-declare function cleanNumStr(str: string | number): string;
+declare function fraction(value: any): number | typeof Infinity | typeof NaN;
+declare function asFraction(value: number | string): string;
+declare function numFraction(value: any): any;
+//#endregion
+//#region src/numbers/parsing/number-input.d.ts
+declare function charCount(character: string | number, value: string): number;
+declare function cleanNumStr(value: string | number): string;
 declare const stripLeadingZeros: (value: string) => string;
-declare function cleanNum(str: string | number): number;
+declare function cleanNum(value: string | number): number;
+//#endregion
+//#region src/numbers/predicates.d.ts
+declare function isNumeric(value: unknown): boolean;
 declare const isNonNumerical: (value: any) => boolean;
+declare function allNumbers(values: (number | string)[]): boolean;
 //#endregion
-//#region src/numbers/display-number.d.ts
+//#region src/numbers/rounding/number-digits.d.ts
+declare function getNumberOfDigitsToShow(value: number | string, maxNumberOfDigits?: number): number;
+//#endregion
+//#region src/numbers/format/display-number.d.ts
 type NumberDisplayOptions = {
   scientific?: 'auto' | boolean;
   eNotation?: boolean;
@@ -347,8 +350,9 @@ type NumberDisplayOptions = {
 };
 declare const displayNumber: <Value extends number | string | null | undefined>(value: Value, options?: NumberDisplayOptions) => string;
 declare const displayNumberToFixed: <Value extends string | null | undefined>(value: Value, options?: NumberDisplayOptions) => string;
+declare const formatNumber: (number: number | string | undefined | null) => string;
 //#endregion
-//#region src/rounding/rounding.d.ts
+//#region src/numbers/rounding/rounding.d.ts
 declare const round: <Value extends number | string | null | undefined>(value: Value, n?: number) => Value;
 declare const roundToPrecision: <Value extends number | string | null | undefined>(value: Value, n?: number) => Value;
 declare const roundToDecimalPrecision: <Value extends number | string | null | undefined>(value: Value, n?: number) => Value;
@@ -357,10 +361,10 @@ declare const roundByMagnitudeToFixed: <Value extends number | string | null | u
 declare const roundByRange: <Value extends number | string | null | undefined>(value: Value, min: number, max: number, n?: number) => Value;
 declare const roundToFixed: <Value extends number | string | null | undefined>(value: Value, n?: number) => Value;
 //#endregion
-//#region src/rounding/cosmetic-rounding.d.ts
+//#region src/numbers/rounding/cosmetic-rounding.d.ts
 declare const roundCosmetic: <Value extends number | string>(value: Value) => Value;
 //#endregion
-//#region src/comparison/comparison.d.ts
+//#region src/numbers/comparison/comparison.d.ts
 type Without<T, U> = { [P in Exclude<keyof T, keyof U>]?: never };
 type XOR<T, U> = T | U extends Record<string, unknown> ? (Without<T, U> & U) | (Without<U, T> & T) : T | U;
 type toleranceType = XOR<{

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/constants.ts","../src/utils.ts","../src/numbers/display-number.ts","../src/rounding/rounding.ts","../src/rounding/cosmetic-rounding.ts","../src/comparison/comparison.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/units/constants.ts","../src/numbers/fractions/fractions.ts","../src/numbers/parsing/number-input.ts","../src/numbers/predicates.ts","../src/numbers/rounding/number-digits.ts","../src/numbers/format/display-number.ts","../src/numbers/rounding/rounding.ts","../src/numbers/rounding/cosmetic-rounding.ts","../src/numbers/comparison/comparison.ts"],"mappings":"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"}

package/dist/index.js

@@ -1,5 +1,26 @@
-import { $ as displayNumber, A as DEPRECATED_UNITS, B as asFraction, C as unum, D as withPrettyUnitLabel, E as validateNumber, F as QUANTITIES_DESCRIPTION, G as fraction, H as cleanNum, I as UNITS_DESCRIPTION, J as isFraction, K as getNumberOfDigitsToShow, L as UNIT_ALIASES, M as KNOWN_CONVERSIONS, N as KNOWN_UNITS, O as withUnit, P as LABELS, Q as stripLeadingZeros, R as UNIT_FROM_KEY, S as unitFromQuantity, T as validateAndClean, U as cleanNumStr, V as charCount, W as formatNumber, X as isNumeric, Y as isNonNumerical, Z as numFraction, _ as showAltUnitsList, a as convertAndGetValue, at as roundToDecimalPrecision, b as toBase, c as convertTable, ct as isCloseTo, d as getUnit, dt as isDeepCloseTo, et as displayNumberToFixed, f as getUnitsForQuantity, ft as isScientificStringNum, g as roundNumberWithLabel, h as label, ht as toString, i as checkAndCleanDecimalComma, it as roundByRange, j as INTERMEDIATE_CONVERSIONS, k as ALT_UNITS, l as getAltUnitsListByQuantity, lt as isCloseToOrGreaterThan, m as isValueWithUnit, mt as toNum, nt as roundByMagnitude, o as convertAndGetValueStrict, ot as roundToFixed, p as getValue, pt as isValidNum, q as isEmptyValueWithUnit, r as altUnitsList, rt as roundByMagnitudeToFixed, s as convertSamePrecision, st as roundToPrecision, tt as round, u as getQuantities, ut as isCloseToOrLessThan, v as split, w as unumWithUnit, x as unitFromKey, y as to, z as allNumbers } from "./units2.js";
-//#region src/rounding/cosmetic-rounding.ts
+import { $ as showAltUnitsList, A as isNonNumerical, B as isEmptyValueWithUnit, C as roundToFixed, D as isCloseToOrLessThan, E as isCloseToOrGreaterThan, F as isFraction, G as charCount, H as split, I as numFraction, J as stripLeadingZeros, K as cleanNum, N as asFraction, O as isDeepCloseTo, P as fraction, Q as label, R as getUnit, S as roundToDecimalPrecision, T as isCloseTo, U as withPrettyUnitLabel, V as isValueWithUnit, W as withUnit, X as getQuantities, Y as getAltUnitsListByQuantity, Z as getUnitsForQuantity, _ as formatNumber, a as toBase, at as KNOWN_CONVERSIONS, b as roundByMagnitudeToFixed, c as checkAndCleanDecimalComma, ct as QUANTITIES_DESCRIPTION, d as isScientificStringNum, dt as UNIT_FROM_KEY, et as unitFromKey, f as isValidNum, g as displayNumberToFixed, h as displayNumber, i as to, it as INTERMEDIATE_CONVERSIONS, j as isNumeric, k as allNumbers, l as validateAndClean, lt as UNITS_DESCRIPTION, m as toString, n as convertAndGetValueStrict, nt as ALT_UNITS, o as unum, ot as KNOWN_UNITS, p as toNum, q as cleanNumStr, r as convertSamePrecision, rt as DEPRECATED_UNITS, s as unumWithUnit, st as LABELS, t as convertAndGetValue, tt as unitFromQuantity, u as validateNumber, ut as UNIT_ALIASES, v as round, w as roundToPrecision, x as roundByRange, y as roundByMagnitude, z as getValue } from "./chunks/conversion.js";
+import { n as roundNumberWithLabel, r as convertTable, t as altUnitsList } from "./chunks/units.js";
+//#region src/numbers/rounding/number-digits.ts
+/**
+* Calculates a useful decimal precision for small values used by legacy rounding.
+*
+* @deprecated Use `roundByMagnitude` or another current rounding function instead.
+*/
+function getNumberOfDigitsToShow(value, maxNumberOfDigits = 20) {
+	const defaultDigits = Math.min(4, maxNumberOfDigits);
+	let digits = defaultDigits;
+	if (typeof value !== "number") return defaultDigits;
+	const valueString = String(value);
+	if (/-?[0-9.,]*[Ee]-?[0-9]+/.test(valueString)) {
+		while (Math.abs(value) * 10 ** digits < 1 && digits < maxNumberOfDigits) digits += 1;
+		return Math.min(digits + (defaultDigits - 1), maxNumberOfDigits);
+	}
+	if (value > 1 || value < -1) return defaultDigits;
+	for (let index = 2; index < valueString.length; index += 1) if (valueString[index] !== "0") return Math.min(maxNumberOfDigits, digits + index - 2);
+	return digits;
+}
+//#endregion
+//#region src/numbers/rounding/cosmetic-rounding.ts
 const COSMETIC_ROUNDING_DEFAULT_PRECISION = 14;
 /**
 * Applies display-only rounding to remove floating-point conversion noise.