shelving 1.89.4 → 1.89.6

package/package.json

@@ -11,7 +11,7 @@
 		"state-management",
 		"query-builder"
 	],
-	"version": "1.89.4",
+	"version": "1.89.6",
 	"repository": "https://github.com/dhoulb/shelving",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"license": "0BSD",

package/util/debug.d.ts

@@ -2,16 +2,15 @@
 import type { ImmutableArray } from "./array.js";
 import type { ImmutableMap } from "./map.js";
 import type { ImmutableSet } from "./set.js";
-import type { ImmutableObject } from "./object.js";
 /** Debug a random value as a string. */
-export declare function debug(value: unknown): string;
+export declare function debug(value: unknown, depth?: number): string;
 /** Debug a string. */
 export declare const debugString: (value: string) => string;
 /** Debug an array. */
-export declare function debugArray(value: ImmutableArray): string;
+export declare function debugArray(value: ImmutableArray, depth?: number): string;
 /** Debug a set. */
-export declare function debugSet(value: ImmutableSet): string;
+export declare function debugSet(value: ImmutableSet, depth?: number): string;
 /** Debug a map. */
-export declare function debugMap(value: ImmutableMap): string;
+export declare function debugMap(value: ImmutableMap, depth?: number): string;
 /** Debug an object. */
-export declare function debugObject(value: ImmutableObject): string;
+export declare function debugObject(value: object, depth?: number): string;

package/util/debug.js

@@ -1,6 +1,6 @@
 /* eslint-disable no-control-regex */
 /** Debug a random value as a string. */
-export function debug(value) {
+export function debug(value, depth = 1) {
     if (value === null)
         return "null";
     if (value === undefined)
@@ -21,12 +21,12 @@ export function debug(value) {
         if (value instanceof Error)
             return value.toString();
         if (value instanceof Array)
-            return debugArray(value);
+            return debugArray(value, depth);
         if (value instanceof Map)
-            return debugMap(value);
+            return debugMap(value, depth);
         if (value instanceof Set)
-            return debugSet(value);
-        return debugObject(value);
+            return debugSet(value, depth);
+        return debugObject(value, depth);
     }
     return typeof value;
 }
@@ -36,29 +36,42 @@ const ESCAPE_REGEXP = /[\x00-\x08\x0B-\x1F\x7F-\x9F"\\]/g; // Match control char
 const ESCAPE_LIST = { '"': '\\"', "\\": "\\\\", "\r": "\\r", "\n": "\\n", "\t": "\\t", "\b": "\\b", "\f": "\\f", "\v": "\\v" };
 const _escapeChar = (char) => ESCAPE_LIST[char] || `\\x${char.charCodeAt(0).toString(16).padStart(2, "00")}`;
 /** Debug an array. */
-export function debugArray(value) {
+export function debugArray(value, depth = 1) {
     const prototype = Object.getPrototypeOf(value);
     const name = prototype === Array.prototype ? "" : prototype.constructor.name || "";
-    return `${name ? `${name} ` : ""}${value.length ? `[\n\t${value.map(debug).join(",\n\t")}\n]` : "[]"}`;
+    const items = depth > 0 && value.length ? value.map(v => debug(v, depth - 1)).join(",\n\t") : "";
+    return `${name ? `${name} ` : ""}${value.length ? `[\n\t${items}\n]` : "[]"}`;
 }
 /** Debug a set. */
-export function debugSet(value) {
+export function debugSet(value, depth = 1) {
     const prototype = Object.getPrototypeOf(value);
     const name = prototype === Set.prototype ? "" : prototype.constructor.name || "Set";
-    return `${name}(value.size) ${value.size ? `{\n\t${Array.from(value).map(debug).join(",\n\t")}\n}` : "{}"}`;
+    const items = depth > 0 && value.size
+        ? Array.from(value)
+            .map(v => debug(v, depth - 1))
+            .join(",\n\t")
+        : "";
+    return `${name}(value.size) ${items ? `{\n\t${items}\n}` : "{}"}`;
 }
 /** Debug a map. */
-export function debugMap(value) {
+export function debugMap(value, depth = 1) {
     const prototype = Object.getPrototypeOf(value);
     const name = prototype === Map.prototype ? "" : prototype.constructor.name || "Map";
-    return `${name}(value.size) ${value.size ? `{\n\t${Array.from(value).map(_debugProp).join(",\n\t")}\n}` : "{}"}`;
+    const entries = depth > 0 && value.size
+        ? Array.from(value)
+            .map(([k, v]) => `${debug(k)}: ${debug(v, depth - 1)}`)
+            .join(",\n\t")
+        : "";
+    return `${name}(value.size) ${entries ? `{\n\t${entries}\n}` : "{}"}`;
 }
 /** Debug an object. */
-export function debugObject(value) {
+export function debugObject(value, depth = 1) {
     const prototype = Object.getPrototypeOf(value);
     const name = prototype === Object.prototype ? "" : prototype.constructor.name || "";
-    const props = Object.entries(value).map(_debugProp);
-    return `${name ? `${name} ` : ""}${props.length ? `{\n\t${props.join(",\n\t")}\n}` : "{}"}`;
+    const entries = depth > 0
+        ? Object.entries(value)
+            .map(([k, v]) => `${debug(k)}: ${debug(v, depth - 1)}`)
+            .join(",\n\t")
+        : "";
+    return `${name ? `${name} ` : ""}${entries ? `{\n\t${entries}\n}` : "{}"}`;
 }
-/** Debug a prop. */
-const _debugProp = ([key, value]) => `${debug(key)}: ${debug(value)}`;

package/util/duration.d.ts

@@ -1,17 +1,17 @@
 import { PossibleDate } from "./date.js";
 /** Format a full format of a duration of time using the most reasonable units e.g. `5 years` or `1 week` or `4 minutes` or `12 milliseconds`. */
-export declare function formatFullDuration(ms: number): string;
+export declare function pluralizeDuration(ms: number): string;
 /** Format a description of a duration of time using the most reasonable units e.g. `5y` or `4m` or `12ms`. */
 export declare function formatDuration(ms: number): string;
 /** Full when a date happens/happened, e.g. `in 10 days` or `2 hours ago` */
-export declare const formatFullWhen: (target: PossibleDate, current?: PossibleDate) => string;
+export declare const pluralizeWhen: (target: PossibleDate, current?: PossibleDate) => string;
 /** Compact when a date happens/happened, e.g. `in 10d` or `2h ago` or `in 1w` */
 export declare const formatWhen: (target: PossibleDate, current?: PossibleDate) => string;
 /** Full when a date happens, e.g. `10 days` or `2 hours` or `-1 week` */
-export declare const formatFullUntil: (target: PossibleDate, current?: PossibleDate) => string;
+export declare const pluralizeUntil: (target: PossibleDate, current?: PossibleDate) => string;
 /** Compact when a date happens, e.g. `10d` or `2h` or `-1w` */
 export declare const formatUntil: (target: PossibleDate, current?: PossibleDate) => string;
 /** Full when a date happened, e.g. `10 days` or `2 hours` or `-1 week` */
-export declare const formatFullAgo: (target: PossibleDate, current?: PossibleDate) => string;
+export declare const pluralizeAgo: (target: PossibleDate, current?: PossibleDate) => string;
 /** Compact when a date will happen, e.g. `10d` or `2h` or `-1w` */
 export declare const formatAgo: (target: PossibleDate, current?: PossibleDate) => string;

package/util/duration.js

@@ -20,15 +20,17 @@ function _getTimeUnit(ms) {
         return TIME_UNITS.unit("second");
     return TIME_UNITS.unit("millisecond");
 }
+/** Default number options for duration (no decimal places and rounding down). */
+const NUMBER_OPTIONS = { maximumFractionDigits: 0, roundingMode: "trunc" };
 /** Format a full format of a duration of time using the most reasonable units e.g. `5 years` or `1 week` or `4 minutes` or `12 milliseconds`. */
-export function formatFullDuration(ms) {
+export function pluralizeDuration(ms) {
     const unit = _getTimeUnit(ms);
-    return unit.formatFull(unit.from(ms), 0);
+    return unit.pluralize(unit.from(ms), NUMBER_OPTIONS);
 }
 /** Format a description of a duration of time using the most reasonable units e.g. `5y` or `4m` or `12ms`. */
 export function formatDuration(ms) {
     const unit = _getTimeUnit(ms);
-    return unit.format(unit.from(ms), 0);
+    return unit.format(unit.from(ms), NUMBER_OPTIONS);
 }
 /** format when a data happens/happened. */
 function _formatWhen(formatter, target, current) {
@@ -38,14 +40,14 @@ function _formatWhen(formatter, target, current) {
     return abs < 10 * SECOND ? "just now" : ms > 0 ? `in ${duration}` : `${duration} ago`;
 }
 /** Full when a date happens/happened, e.g. `in 10 days` or `2 hours ago` */
-export const formatFullWhen = (target, current) => _formatWhen(formatFullDuration, target, current);
+export const pluralizeWhen = (target, current) => _formatWhen(pluralizeDuration, target, current);
 /** Compact when a date happens/happened, e.g. `in 10d` or `2h ago` or `in 1w` */
 export const formatWhen = (target, current) => _formatWhen(formatDuration, target, current);
 /** Full when a date happens, e.g. `10 days` or `2 hours` or `-1 week` */
-export const formatFullUntil = (target, current) => formatFullDuration(getDuration(target, current));
+export const pluralizeUntil = (target, current) => pluralizeDuration(getDuration(target, current));
 /** Compact when a date happens, e.g. `10d` or `2h` or `-1w` */
 export const formatUntil = (target, current) => formatDuration(getDuration(target, current));
 /** Full when a date happened, e.g. `10 days` or `2 hours` or `-1 week` */
-export const formatFullAgo = (target, current) => formatFullDuration(getDuration(current, target));
+export const pluralizeAgo = (target, current) => pluralizeDuration(getDuration(current, target));
 /** Compact when a date will happen, e.g. `10d` or `2h` or `-1w` */
 export const formatAgo = (target, current) => formatDuration(getDuration(current, target));

package/util/number.d.ts

@@ -59,8 +59,7 @@ export declare const roundNumber: (num: number, precision?: number) => number;
  * - Better than `Math.trunc()` because it allows a `precision` argument.
  *
  * @param num The number to truncate.
- * @param precision Maximum number of digits shown after the decimal point (defaults to 10).
- *
+ * @param precision Maximum number of digits shown after the decimal point (defaults to 0).
  * @returns The number truncated to the specified precision.
  */
 export declare const truncateNumber: (num: number, precision?: number) => number;
@@ -68,51 +67,35 @@ export declare const truncateNumber: (num: number, precision?: number) => number
 export declare function boundNumber(num: number, min: number, max: number): number;
 /** Wrap a number so it fits between two values. */
 export declare function wrapNumber(num: number, min: number, max: number): number;
+/** Options for `formatNumber()` and `formatRange()`. */
+export interface NumberOptions extends Intl.NumberFormatOptions {
+    roundingMode?: "ceil" | "floor" | "expand" | "trunc" | "halfCeil" | "halfFloor" | "halfExpand" | "halfTrunc" | "halfEven" | undefined;
+    roundingPriority?: "morePrecision" | "lessPrecision" | undefined;
+}
 /** Format a number (based on the user's browser language settings). */
-export declare function formatNumber(num: number, precision?: number | null): string;
+export declare function formatNumber(num: number, options?: NumberOptions): string;
 /** Format a number range (based on the user's browser language settings). */
-export declare function formatRange(min: number, max: number, precision?: number | null): string;
+export declare function formatRange(min: number, max: number, options?: NumberOptions): string;
 /** Format a number with a short suffix, e.g. `1,000 kg` */
-export declare const formatQuantity: (num: number, abbr: string, precision?: number | null) => string;
+export declare const formatQuantity: (num: number, abbr: string, options?: NumberOptions) => string;
 /** Format a number with a longer full-word suffix. */
-export declare function formatFullQuantity(num: number, singular: string, plural: string, precision?: number | null): string;
+export declare function pluralizeQuantity(num: number, singular: string, plural: string, options?: NumberOptions): string;
 /**
- * Cram a large whole numbers into a space efficient format, e.g. `14.7M`
- * - Improves glanceability.
- * - Keeps number of characters under five if possible.
- *
- * - Numbers over 100 trillion: `157T`
- * - Numbers over 10 trillion: `15.7T` (includes zero e.g. `40.0T` for consistency).
- * - Numbers over 1 trillion: `1.57T` (includes zeros e.g. `4.00T` for consistency).
- * - Numbers over 100 billion: `157B`
- * - Numbers over 10 billion: `15.7B` (includes zero e.g. `40.0B` for consistency).
- * - Numbers over 1 billion: `1.57B` (includes zeros e.g. `4.00B` for consistency).
- * - Numbers over 100 million: `157M`
- * - Numbers over 10 million: `15.7M` (includes zero e.g. `40.0M` for consistency).
- * - Numbers over 1 million: `1.57M` (includes zeros e.g. `4.00M` for consistency).
- * - Numbers over 100,000: `157K`
- * - Numbers over 10,000: `15.7K` (includes zero e.g. `14.0K` for consistency).
- * - Smaller numbers: `1570` and `157` and `15.7` and `1.6`
- *
- * @param num The number to format.
- * @param precision Maximum number of digits shown after the decimal point (defaults to 10, only used for numbers under 10,000).
+ * Get a number as a percentage of another number.
  *
- * @returns The number formatted as a crammed string.
+ * @param numerator Number representing the amount of progress.
+ * @param denumerator The number representing the whole amount.
  */
-export declare function cramNumber(num: number): string;
-/** Cram a number with a short suffix, e.g. `1.02M kg` */
-export declare const cramQuantity: (num: number, suffix: string) => string;
-/** Cram a number with a longer full-word suffix. */
-export declare function cramFullQuantity(num: number, singular: string, plural: string): string;
+export declare const getPercent: (numerator: number, denumerator: number) => number;
 /**
- * Get a number as a percentage of another number.
+ * Format a percentage (combines `getPercent()` and `formatQuantity()` for convenience).
+ * - Defaults to showing no decimal places.
+ * - Defaults to rounding closer to zero (so that 99.99% is shown as 99%).
  *
  * @param numerator Number representing the amount of progress.
  * @param denumerator The number representing the whole amount.
  */
-export declare const getPercent: (numerator: number, denumerator: number) => number;
-/** Format a percentage (combines `getPercent()` and `formatQuantity()` for convenience). */
-export declare const formatPercent: (numerator: number, denumerator: number, precision?: number) => string;
+export declare const formatPercent: (numerator: number, denumerator: number, options?: NumberOptions) => string;
 /** Sum an iterable set of numbers and return the total. */
 export declare function sumNumbers(nums: Iterable<number>): number;
 /** Find the number that's closest to a target in an iterable set of numbers. */

package/util/number.js

@@ -1,5 +1,5 @@
 import { AssertionError } from "../error/AssertionError.js";
-import { BILLION, MILLION, NNBSP, TEN_THOUSAND, THOUSAND, TRILLION } from "./constants.js";
+import { NNBSP } from "./constants.js";
 /** Is a value a number? */
 export const isNumber = (value) => typeof value === "number";
 /** Assert that a value is a number. */
@@ -89,8 +89,7 @@ export const roundNumber = (num, precision = 0) => Math.round(num * 10 ** precis
  * - Better than `Math.trunc()` because it allows a `precision` argument.
  *
  * @param num The number to truncate.
- * @param precision Maximum number of digits shown after the decimal point (defaults to 10).
- *
+ * @param precision Maximum number of digits shown after the decimal point (defaults to 0).
  * @returns The number truncated to the specified precision.
  */
 export const truncateNumber = (num, precision = 0) => Math.trunc(num * 10 ** precision) / 10 ** precision;
@@ -109,79 +108,40 @@ export function wrapNumber(num, min, max) {
     return num;
 }
 /** Format a number (based on the user's browser language settings). */
-export function formatNumber(num, precision = null) {
+export function formatNumber(num, options = { maximumFractionDigits: 2 }) {
     if (Number.isNaN(num))
         return "None";
     if (!Number.isFinite(num))
         return "∞";
-    return new Intl.NumberFormat(undefined, { minimumFractionDigits: precision !== null && precision !== void 0 ? precision : undefined, maximumFractionDigits: precision !== null && precision !== void 0 ? precision : 20 }).format(num);
+    return new Intl.NumberFormat(undefined, options).format(num);
 }
 /** Format a number range (based on the user's browser language settings). */
-export function formatRange(min, max, precision = null) {
-    return `${formatNumber(min, precision)}–${formatNumber(max, precision)}`;
+export function formatRange(min, max, options) {
+    return `${formatNumber(min, options)}–${formatNumber(max, options)}`;
 }
 /** Format a number with a short suffix, e.g. `1,000 kg` */
-export const formatQuantity = (num, abbr, precision) => `${formatNumber(num, precision)}${NNBSP}${abbr}`;
+export const formatQuantity = (num, abbr, options) => `${formatNumber(num, options)}${NNBSP}${abbr}`;
 /** Format a number with a longer full-word suffix. */
-export function formatFullQuantity(num, singular, plural, precision) {
-    const qty = formatNumber(num, precision);
+export function pluralizeQuantity(num, singular, plural, options) {
+    const qty = formatNumber(num, options);
     return `${qty} ${qty === "1" ? singular : plural}`;
 }
 /**
- * Cram a large whole numbers into a space efficient format, e.g. `14.7M`
- * - Improves glanceability.
- * - Keeps number of characters under five if possible.
- *
- * - Numbers over 100 trillion: `157T`
- * - Numbers over 10 trillion: `15.7T` (includes zero e.g. `40.0T` for consistency).
- * - Numbers over 1 trillion: `1.57T` (includes zeros e.g. `4.00T` for consistency).
- * - Numbers over 100 billion: `157B`
- * - Numbers over 10 billion: `15.7B` (includes zero e.g. `40.0B` for consistency).
- * - Numbers over 1 billion: `1.57B` (includes zeros e.g. `4.00B` for consistency).
- * - Numbers over 100 million: `157M`
- * - Numbers over 10 million: `15.7M` (includes zero e.g. `40.0M` for consistency).
- * - Numbers over 1 million: `1.57M` (includes zeros e.g. `4.00M` for consistency).
- * - Numbers over 100,000: `157K`
- * - Numbers over 10,000: `15.7K` (includes zero e.g. `14.0K` for consistency).
- * - Smaller numbers: `1570` and `157` and `15.7` and `1.6`
- *
- * @param num The number to format.
- * @param precision Maximum number of digits shown after the decimal point (defaults to 10, only used for numbers under 10,000).
+ * Get a number as a percentage of another number.
  *
- * @returns The number formatted as a crammed string.
+ * @param numerator Number representing the amount of progress.
+ * @param denumerator The number representing the whole amount.
  */
-export function cramNumber(num) {
-    const abs = Math.abs(num);
-    if (abs >= TRILLION)
-        return `${_significance(num / TRILLION)}T`;
-    if (abs >= BILLION)
-        return `${_significance(num / BILLION)}B`;
-    if (abs >= MILLION)
-        return `${_significance(num / MILLION)}M`;
-    if (abs >= TEN_THOUSAND)
-        return `${_significance(num / THOUSAND)}K`;
-    return truncateNumber(num, 2).toString();
-}
-function _significance(num) {
-    const digits = num >= 100 ? 0 : num >= 10 ? 1 : 2;
-    return truncateNumber(num, digits).toFixed(digits);
-}
-/** Cram a number with a short suffix, e.g. `1.02M kg` */
-export const cramQuantity = (num, suffix) => `${cramNumber(num)}${NNBSP}${suffix}`;
-/** Cram a number with a longer full-word suffix. */
-export function cramFullQuantity(num, singular, plural) {
-    const qty = cramNumber(num);
-    return `${qty} ${qty === "1" ? singular : plural}`;
-}
+export const getPercent = (numerator, denumerator) => Math.max(0, Math.min(100, (100 / denumerator) * numerator));
 /**
- * Get a number as a percentage of another number.
+ * Format a percentage (combines `getPercent()` and `formatQuantity()` for convenience).
+ * - Defaults to showing no decimal places.
+ * - Defaults to rounding closer to zero (so that 99.99% is shown as 99%).
  *
  * @param numerator Number representing the amount of progress.
  * @param denumerator The number representing the whole amount.
  */
-export const getPercent = (numerator, denumerator) => Math.max(0, Math.min(100, (100 / denumerator) * numerator));
-/** Format a percentage (combines `getPercent()` and `formatQuantity()` for convenience). */
-export const formatPercent = (numerator, denumerator, precision) => formatQuantity(getPercent(numerator, denumerator), "%", precision);
+export const formatPercent = (numerator, denumerator, options) => formatQuantity(getPercent(numerator, denumerator), "%", { maximumFractionDigits: 0, roundingMode: "trunc", ...options });
 /** Sum an iterable set of numbers and return the total. */
 export function sumNumbers(nums) {
     let sum = 0;

package/util/units.d.ts

@@ -1,12 +1,12 @@
 import { ImmutableObject } from "./object.js";
 import { MapKey, ImmutableMap } from "./map.js";
+import { NumberOptions } from "./number.js";
 /** Conversion from one unit to another (either an amount to multiple by, or a function to convert). */
 type Conversion = number | ((num: number) => number);
 /** Set of possible conversions for a set of items. */
 type Conversions<T extends string> = {
     readonly [K in T]?: Conversion;
 };
-/** Get a `Unit` instance from a `UnitList` instance */
 type UnitProps<T extends string> = {
     /** Short abbreviation for this unit, e.g. `km` (defaults to first letter of `id`). */
     readonly abbr?: string;
@@ -14,8 +14,6 @@ type UnitProps<T extends string> = {
     readonly singular?: string;
     /** Plural name for this unit, e.g. `kilometers` (defaults to `id`). */
     readonly plural?: string;
-    /** Default precision for this unit (defaults to `null`). */
-    readonly precision?: number | null;
     /** Conversions to other units (typically needs at least the base conversion, unless it's already the base unit). */
     readonly to?: Conversions<T>;
 };
@@ -32,8 +30,6 @@ export declare class Unit<K extends string> {
     readonly singular: string;
     /** Plural name for this unit, e.g. `kilometers` (defaults to `singular` + "s"). */
     readonly plural: string;
-    /** Default precision for this unit (defaults to `null`). */
-    readonly precision: number | null;
     /** Title for this unit (uses format `abbr (plural)`, e.g. `fl oz (US fluid ounces)`) */
     get title(): string;
     constructor(
@@ -42,7 +38,7 @@ export declare class Unit<K extends string> {
     /** String key for this unit, e.g. `kilometer` */
     key: K, 
     /** Props to configure this unit. */
-    { abbr, singular, plural, precision, to }: UnitProps<K>);
+    { abbr, singular, plural, to }: UnitProps<K>);
     /** Convert an amount from this unit to another unit. */
     to(amount: number, unit?: K | Unit<K>): number;
     /** Convert an amount from another unit to this unit. */
@@ -50,11 +46,9 @@ export declare class Unit<K extends string> {
     /** Convert an amount from this unit to another unit (must specify another `Unit` instance). */
     private _toUnit;
     /** Format an amount with a given unit of measure, e.g. `12 kg` or `29.5 l` */
-    format(amount: number, precision?: number | null): string;
+    format(amount: number, options?: NumberOptions): string;
     /** Format an amount with a given unit of measure, e.g. `12 kilograms` or `29.5 liters` or `1 degree` */
-    formatFull(amount: number, precision?: number | null): string;
-    /** Cram an amount with a given unit of measure, e.g. `1.25M mi` */
-    cram(amount: number): string;
+    pluralize(amount: number, options?: NumberOptions): string;
 }
 /**
  * Represent a list of units.

package/util/units.js

@@ -3,7 +3,7 @@ import { RequiredError } from "../error/RequiredError.js";
 import { DAY, HOUR, MILLION, MINUTE, MONTH, NNBSP, SECOND, WEEK, YEAR } from "./constants.js";
 import { getProps } from "./object.js";
 import { ImmutableMap } from "./map.js";
-import { cramQuantity, formatFullQuantity, formatQuantity } from "./number.js";
+import { pluralizeQuantity, formatQuantity } from "./number.js";
 /** Convert an amount using a `Conversion. */
 const _convert = (amount, conversion) => (typeof conversion === "function" ? conversion(amount) : conversion === 1 ? amount : amount * conversion);
 /** Represent a unit. */
@@ -18,13 +18,12 @@ export class Unit {
     /** String key for this unit, e.g. `kilometer` */
     key, 
     /** Props to configure this unit. */
-    { abbr = key.slice(0, 1), singular = key.replace(/-/, " "), plural = `${singular}s`, precision = null, to }) {
+    { abbr = key.slice(0, 1), singular = key.replace(/-/, " "), plural = `${singular}s`, to }) {
         this.list = list;
         this.key = key;
         this.abbr = abbr;
         this.singular = singular;
         this.plural = plural;
-        this.precision = precision;
         this._to = to;
     }
     /** Convert an amount from this unit to another unit. */
@@ -58,16 +57,12 @@ export class Unit {
         throw new ConditionError(`Cannot convert "${this.key}" to "${unit.key}"`);
     }
     /** Format an amount with a given unit of measure, e.g. `12 kg` or `29.5 l` */
-    format(amount, precision = this.precision) {
-        return formatQuantity(amount, this.abbr, precision);
+    format(amount, options) {
+        return formatQuantity(amount, this.abbr, options);
     }
     /** Format an amount with a given unit of measure, e.g. `12 kilograms` or `29.5 liters` or `1 degree` */
-    formatFull(amount, precision = this.precision) {
-        return formatFullQuantity(amount, this.singular, this.plural, precision);
-    }
-    /** Cram an amount with a given unit of measure, e.g. `1.25M mi` */
-    cram(amount) {
-        return cramQuantity(amount, this.abbr);
+    pluralize(amount, options) {
+        return pluralizeQuantity(amount, this.singular, this.plural, options);
     }
 }
 /**