shelving 1.86.0 → 1.86.2

package/util/object.d.ts

@@ -1,18 +1,18 @@
 import type { ImmutableArray } from "./array.js";
 /** Any readonly objet. */
-export declare type ImmutableObject<K extends PropertyKey = PropertyKey, T = unknown> = {
+export type ImmutableObject<K extends PropertyKey = PropertyKey, T = unknown> = {
     readonly [KK in K]: T;
 };
 /** Any writable object. */
-export declare type MutableObject<K extends PropertyKey = PropertyKey, T = unknown> = {
+export type MutableObject<K extends PropertyKey = PropertyKey, T = unknown> = {
     [KK in K]: T;
 };
 /** Prop for an object. */
-export declare type ObjectProp<T extends ImmutableObject = ImmutableObject> = readonly [keyof T, T[keyof T]];
+export type ObjectProp<T extends ImmutableObject = ImmutableObject> = readonly [keyof T, T[keyof T]];
 /** Key for an object prop. */
-export declare type ObjectKey<T extends ImmutableObject = ImmutableObject> = keyof T;
+export type ObjectKey<T extends ImmutableObject = ImmutableObject> = keyof T;
 /** Value for an object prop. */
-export declare type ObjectValue<T extends ImmutableObject = ImmutableObject> = T[keyof T];
+export type ObjectValue<T extends ImmutableObject = ImmutableObject> = T[keyof T];
 /** Is an unknown value an unknown object? */
 export declare const isObject: <T extends ImmutableObject<PropertyKey, unknown>>(value: unknown) => value is T;
 /** Assert that a value is an object */
@@ -28,7 +28,7 @@ export declare const isProp: <T extends ImmutableObject<PropertyKey, unknown>>(o
  * - See https://github.com/microsoft/TypeScript/issues/24509
  * - Consistency with `Readonly<T>`
  */
-export declare type Mutable<T> = {
+export type Mutable<T> = {
     -readonly [K in keyof T]: T[K];
 };
 /**
@@ -36,7 +36,7 @@ export declare type Mutable<T> = {
  * - Any value that extends `UnknownObject` has its props made partial.
  * - Works deeply on nested objects too.
  */
-export declare type DeepPartial<T> = {
+export type DeepPartial<T> = {
     [K in keyof T]?: DeepPartial<T[K]>;
 };
 /**
@@ -44,7 +44,7 @@ export declare type DeepPartial<T> = {
  * - Any value that extends `UnknownObject` has its props made mutable.
  * - Works deeply on nested objects too.
  */
-export declare type DeepMutable<T> = {
+export type DeepMutable<T> = {
     -readonly [K in keyof T]: DeepMutable<T[K]>;
 };
 /**
@@ -52,15 +52,15 @@ export declare type DeepMutable<T> = {
  * - Any value that extends `UnknownObject` has its props made readonly.
  * - Works deeply on nested objects too.
  */
-export declare type DeepReadonly<T> = {
+export type DeepReadonly<T> = {
     +readonly [K in keyof T]: DeepReadonly<T[K]>;
 };
 /** Pick only the properties of an object that match a type. */
-export declare type PickProps<T, TT> = Pick<T, {
+export type PickProps<T, TT> = Pick<T, {
     [K in keyof T]: T[K] extends TT ? K : never;
 }[keyof T]>;
 /** Omit the properties of an object that match a type. */
-export declare type OmitProps<T, TT> = Omit<T, {
+export type OmitProps<T, TT> = Omit<T, {
     [K in keyof T]: T[K] extends TT ? K : never;
 }[keyof T]>;
 /** Get the props of an object as a set of entries. */
@@ -84,6 +84,7 @@ export declare function getProp<T extends ImmutableObject, K1 extends keyof T>(o
 /** Set a prop on an object (immutably) and return a new object including that prop. */
 export declare function withProp<T extends ImmutableObject, K extends keyof T>(input: T, key: K, value: T[K]): T;
 /** Set several props on an object (immutably) and return a new object including those props. */
+export declare function withProps<T>(input: T, props: Partial<T>): T;
 export declare function withProps<T extends ImmutableObject>(input: T, props: T | Partial<T> | Iterable<ObjectProp<T>>): T;
 /** Remove several props from an object (immutably) and return a new object without those props. */
 export declare function omitProps<T extends ImmutableObject, K extends keyof T>(input: T, ...keys: K[]): Omit<T, K>;
@@ -95,3 +96,15 @@ export declare function setProp<T extends MutableObject, K extends keyof T>(obj:
 export declare function setProps<T extends MutableObject>(obj: T, entries: T | Partial<T> | Iterable<ObjectProp<T>>): void;
 /** Remove several key/value entries from an object (by reference). */
 export declare function deleteProps<T extends MutableObject>(obj: T, ...keys: (keyof T)[]): void;
+/**
+ * Format an unknown object as a string.
+ * - Use the custom `.toString()` function if it exists (don't use built in `Object.prototype.toString` because it's useless.
+ * - Use `.title` or `.name` or `.id` if they exist and are strings.
+ * - Use `Object` otherwise.
+ */
+export declare function formatObject(obj: ImmutableObject): string;
+/**
+ * Get the prototype of an object instance.
+ * - Recommend to use this because Typescript's default lib specifies `Object.getPrototypeOf()` returning `any`.
+ */
+export declare function getPrototype<T>(obj: T): Partial<T> | null;

package/util/object.js

@@ -10,7 +10,7 @@ export function assertObject(value) {
 /** is an unknown value an unknown plain object? */
 export function isPlainObject(value) {
     if (isObject(value)) {
-        const proto = Object.getPrototypeOf(value);
+        const proto = getPrototype(value);
         return proto === null || proto === Object.prototype;
     }
     return false;
@@ -30,13 +30,12 @@ export function getProp(data, k1, k2, k3, k4) {
 }
 /** Set a prop on an object (immutably) and return a new object including that prop. */
 export function withProp(input, key, value) {
-    return input[key] === value ? input : { ...input, [key]: value };
+    return input[key] === value ? input : { __proto__: getPrototype(input), ...input, [key]: value };
 }
-/** Set several props on an object (immutably) and return a new object including those props. */
 export function withProps(input, props) {
     for (const [k, v] of getProps(props))
         if (input[k] !== v)
-            return { ...input, ...props };
+            return { __proto__: getPrototype(input), ...input, ...props };
     return input;
 }
 export function omitProps(input, ...keys) {
@@ -69,3 +68,30 @@ export function deleteProps(obj, ...keys) {
     for (const key of keys)
         delete obj[key];
 }
+/**
+ * Format an unknown object as a string.
+ * - Use the custom `.toString()` function if it exists (don't use built in `Object.prototype.toString` because it's useless.
+ * - Use `.title` or `.name` or `.id` if they exist and are strings.
+ * - Use `Object` otherwise.
+ */
+export function formatObject(obj) {
+    if (typeof obj.toString === "function" && obj.toString !== Object.prototype.toString)
+        return obj.toString();
+    const name = obj.name;
+    if (typeof name === "string")
+        return name;
+    const title = obj.title;
+    if (typeof title === "string")
+        return title;
+    const id = obj.id;
+    if (typeof id === "string")
+        return id;
+    return "Object";
+}
+/**
+ * Get the prototype of an object instance.
+ * - Recommend to use this because Typescript's default lib specifies `Object.getPrototypeOf()` returning `any`.
+ */
+export function getPrototype(obj) {
+    return Object.getPrototypeOf(obj);
+}

package/util/regexp.d.ts

@@ -5,7 +5,7 @@ export declare const ALWAYS_REGEXP: RegExp;
 /** Regular expression that never matches anything. */
 export declare const NEVER_REGEXP: RegExp;
 /** Things that can be convert to a regular expression. */
-export declare type PossibleRegExp = string | RegExp;
+export type PossibleRegExp = string | RegExp;
 /** Is an unknown value a `RegExp` instance? */
 export declare const isRegExp: <T extends RegExp>(v: unknown) => v is T;
 /** Assert that an unknown value is a `RegExp` instance. */
@@ -17,12 +17,11 @@ export declare const getRegExpSource: (regexp: PossibleRegExp) => string;
 /** Escape special characters in a string regular expression. */
 export declare const escapeRegExp: (pattern: string) => string;
 /** Set of named match groups from a regular expression. */
-export declare type NamedRegExpData = {
+export type NamedRegExpData = {
     [named: string]: string;
 };
 /** Regular expression match array that you've asserted contains the specified named groups. */
 export interface NamedRegExpArray<T extends NamedRegExpData = NamedRegExpData> extends RegExpExecArray {
-    0: string;
     groups: T;
 }
 /** Regular expression that you've asserted contains the specified named capture groups. */

package/util/serialise.js

@@ -1,6 +1,6 @@
 import { AssertionError } from "../error/AssertionError.js";
 import { isArray } from "./array.js";
-import { isObject } from "./object.js";
+import { getPrototype, isObject } from "./object.js";
 const R_QUOTE = /"/g;
 /**
  * Custom JSON.stringify()
@@ -31,7 +31,7 @@ export function serialise(value) {
     if (isArray(value))
         return `[${value.map(serialise).join(",")}]`;
     if (isObject(value)) {
-        const prototype = Object.getPrototypeOf(value);
+        const prototype = getPrototype(value);
         const type = prototype !== Object.prototype && prototype !== null ? (_a = prototype === null || prototype === void 0 ? void 0 : prototype.constructor) === null || _a === void 0 ? void 0 : _a.name : undefined;
         // Use custom `toString()` function if it's defined.
         if (type && value.toString !== Object.prototype.toString)

package/util/set.d.ts

@@ -1,11 +1,11 @@
 /** `Set` that cannot be changed. */
-export declare type ImmutableSet<T = unknown> = ReadonlySet<T>;
+export type ImmutableSet<T = unknown> = ReadonlySet<T>;
 /** `Set` that can be changed. */
-export declare type MutableSet<T = unknown> = Set<T>;
+export type MutableSet<T = unknown> = Set<T>;
 /** Things that can be converted to sets. */
-export declare type PossibleSet<T> = ImmutableSet<T> | Iterable<T>;
+export type PossibleSet<T> = ImmutableSet<T> | Iterable<T>;
 /** Get the type of the _items_ in a set. */
-export declare type SetItem<X> = X extends ReadonlySet<infer Y> ? Y : never;
+export type SetItem<X> = X extends ReadonlySet<infer Y> ? Y : never;
 /** Is an unknown value a set? */
 export declare const isSet: <T extends ImmutableSet<unknown>>(v: unknown) => v is T;
 /** Is an unknown value an item in a set? */

package/util/sort.d.ts

@@ -4,9 +4,9 @@ export interface Rankable<T> {
     rank(left: T, right: T): number;
 }
 /** Function that can rank two values. */
-export declare type Rank<T> = (left: T, right: T) => number;
+export type Rank<T> = (left: T, right: T) => number;
 /** Something that can rank two values. */
-export declare type Ranker<T> = Rankable<T> | Rank<T>;
+export type Ranker<T> = Rankable<T> | Rank<T>;
 /** Rank two values with a `Ranker`. */
 export declare function rank<T>(left: T, ranker: Ranker<T>, right: T): number;
 /**

package/util/source.js

@@ -1,10 +1,10 @@
 import { AssertionError } from "../error/AssertionError.js";
-import { isData } from "./data.js";
+import { isObject } from "./object.js";
 /**
  * Recurse through `Sourceable` objects and return the first one that is an instance of `type`, or `null` if no source object matches.
  */
 export function getOptionalSource(type, value) {
-    if (isData(value)) {
+    if (isObject(value)) {
         if (value instanceof type)
             return value;
         if ("source" in value)

package/util/string.d.ts

@@ -5,7 +5,7 @@ import { ImmutableArray } from "./array.js";
  * - Using `Iterable<string> & NotString` allows an iterable containing strings but not `string` itself.
  * - This helps catch this category of subtle errors.
  */
-export declare type NotString = {
+export type NotString = {
     toUpperCase?: never;
     toLowerCase?: never;
 };

package/util/string.js

@@ -1,7 +1,7 @@
 /* eslint-disable no-control-regex */
 import { AssertionError } from "../error/AssertionError.js";
 import { formatDate, isDate } from "./date.js";
-import { formatData, isData } from "./data.js";
+import { formatObject, isObject } from "./object.js";
 import { getArray, isArray } from "./array.js";
 import { formatNumber, isBetween } from "./number.js";
 /** Is a value a string? */
@@ -41,8 +41,8 @@ export function getString(value) {
         return formatDate(value);
     if (isArray(value))
         return value.map(getString).join(", ");
-    if (isData(value))
-        return formatData(value);
+    if (isObject(value))
+        return formatObject(value);
     return "Unknown";
 }
 /** Concatenate an iterable set of strings together. */

package/util/template.d.ts

@@ -1,9 +1,9 @@
 import type { NotString } from "./string.js";
 import type { ImmutableDictionary } from "./dictionary.js";
 /** Template values in `{ placeholder: value }` format. */
-declare type TemplateValues = ImmutableDictionary<string>;
+type TemplateValues = ImmutableDictionary<string>;
 /** Things that can be converted to the value for a named placeholder. */
-declare type PlaceholderValues = string | ((name: string) => string) | string[] | TemplateValues;
+type PlaceholderValues = string | ((name: string) => string) | string[] | TemplateValues;
 /**
  * Get list of placeholders named in a template string.
  *

package/util/template.js

@@ -1,12 +1,12 @@
 import { isObject } from "./object.js";
+import { setMapItem } from "./map.js";
+import { EMPTY_DATA } from "./data.js";
 // RegExp to find named variables in several formats e.g. `:a`, `${b}`, `{{c}}` or `{d}`
 const R_PLACEHOLDERS = /(\*|:[a-z][a-z0-9]*|\$\{[a-z][a-z0-9]*\}|\{\{[a-z][a-z0-9]*\}\}|\{[a-z][a-z0-9]*\})/i;
 // Find actual name within template placeholder e.g. `${name}` → `name`
 const R_NAME = /[a-z0-9]+/i;
-// Empty template.
-const EMPTY_TEMPLATE = Object.create(null);
 // Cache of templates.
-const TEMPLATE_CACHE = Object.create(null);
+const TEMPLATE_CACHE = new Map();
 /**
  * Split up a template into an array of separator → placeholder → separator → placeholder → separator
  * - Odd numbered chunks are separators.
@@ -15,7 +15,7 @@ const TEMPLATE_CACHE = Object.create(null);
  * @param template The template including template placeholders, e.g. `:name-${country}/{city}`
  * @returns Array of strings alternating separator and placeholder.
  */
-const splitTemplate = (template) => (TEMPLATE_CACHE[template] || (TEMPLATE_CACHE[template] = _split(template)));
+const _splitTemplate = (template) => TEMPLATE_CACHE.get(template) || setMapItem(TEMPLATE_CACHE, template, _split(template));
 const _split = (template) => {
     var _a;
     const matches = template.split(R_PLACEHOLDERS);
@@ -38,7 +38,7 @@ const _split = (template) => {
  * @param template The template including template placeholders, e.g. `:name-${country}/{city}`
  * @returns Array of clean string names of found placeholders, e.g. `["name", "country", "city"]`
  */
-export const getPlaceholders = (template) => splitTemplate(template).map(_getPlaceholder);
+export const getPlaceholders = (template) => _splitTemplate(template).map(_getPlaceholder);
 const _getPlaceholder = ({ name }) => name;
 /**
  * Match a template against a target string.
@@ -51,17 +51,17 @@ const _getPlaceholder = ({ name }) => name;
  */
 export function matchTemplate(template, target) {
     // Get separators and placeholders from template.
-    const chunks = splitTemplate(template);
+    const chunks = _splitTemplate(template);
     const firstChunk = chunks[0];
     // Return early if empty.
     if (!firstChunk)
-        return template === target ? EMPTY_TEMPLATE : undefined;
+        return template === target ? EMPTY_DATA : undefined;
     // Check first separator.
     if (!target.startsWith(firstChunk.pre))
         return undefined; // target doesn't match template
     // Loop through the placeholders (placeholders are at all the even-numbered positions in `chunks`).
     let startIndex = firstChunk.pre.length;
-    const values = Object.create(null);
+    const values = {};
     for (const { name, post } of chunks) {
         const stopIndex = !post ? Infinity : target.indexOf(post, startIndex);
         if (stopIndex < 0)
@@ -96,7 +96,7 @@ export function matchTemplates(templates, target) {
  * @throws {ReferenceError} If a placeholder in the template string is not specified in values.
  */
 export const renderTemplate = (template, value) => {
-    const chunks = splitTemplate(template);
+    const chunks = _splitTemplate(template);
     if (!chunks.length)
         return template;
     let output = template;

package/util/time.d.ts

@@ -33,9 +33,9 @@ export declare class Time {
 /** Regular expression that matches a time in ISO 8601 format. */
 export declare const TIME_REGEXP: RegExp;
 /** Things that converted to times. */
-export declare type PossibleTime = Time | Date | number | string;
+export type PossibleTime = Time | Date | number | string;
 /** Things that converted to times or `null` */
-export declare type PossibleOptionalTime = Time | Date | number | string | null;
+export type PossibleOptionalTime = Time | Date | number | string | null;
 /** Is an unknown value a `Time` instance. */
 export declare const isTime: (v: Time | unknown) => v is Time;
 /**

package/util/time.js

@@ -4,9 +4,6 @@ import { getOptionalDate } from "./date.js";
 import { wrapNumber } from "./number.js";
 /** Class representing a time in the day in 24 hour format in the user's current locale. */
 export class Time {
-    constructor(time) {
-        this.time = wrapNumber(Math.round(time), 0, DAY);
-    }
     /** Make a new `Time` instance from a date (or any value that can be converted to a date). */
     static fromDate(possible) {
         const date = getOptionalDate(possible);
@@ -20,6 +17,9 @@ export class Time {
         const [, h, m, s, ms] = matches;
         return new Time(parseInt(h, 10) * HOUR + parseInt(m, 10) * MINUTE + (typeof s === "string" ? parseInt(s, 10) * SECOND : 0) + (typeof ms === "string" ? parseInt(ms, 10) : 0));
     }
+    constructor(time) {
+        this.time = wrapNumber(Math.round(time), 0, DAY);
+    }
     /** Get the number of hours in this time. */
     get h() {
         return Math.trunc(this.time / HOUR);

package/util/transform.d.ts

@@ -13,13 +13,13 @@ export interface AsyncTransformable<I, O> {
 /** Is an unknown value a transformable. */
 export declare const isTransformable: <T extends Transformable<unknown, unknown>>(v: unknown) => v is T;
 /** Function that can transform an input value into an output value. */
-export declare type Transform<I, O> = (input: I) => O;
+export type Transform<I, O> = (input: I) => O;
 /** Function that can transform an input value into an output value. */
-export declare type AsyncTransform<I, O> = (input: I) => O | PromiseLike<O>;
+export type AsyncTransform<I, O> = (input: I) => O | PromiseLike<O>;
 /** Something that can transform an input value into an output value (or a plain value). */
-export declare type Transformer<I, O> = Transformable<I, O> | Transform<I, O> | O;
+export type Transformer<I, O> = Transformable<I, O> | Transform<I, O> | O;
 /** Something that can transform an input value into an output value (or a plain value). */
-export declare type AsyncTransformer<I, O> = AsyncTransformable<I, O> | AsyncTransform<I, O> | O;
+export type AsyncTransformer<I, O> = AsyncTransformable<I, O> | AsyncTransform<I, O> | O;
 /** Transform a value using a transformer. */
 export declare function transform<I, O>(input: I, transformer: (v: I) => O): O;
 export declare function transform<I, O>(input: I, transformer: (v: I) => O | PromiseLike<O>): O | PromiseLike<O>;
@@ -38,7 +38,7 @@ export declare const mapDictionary: <I, O>(dictionary: ImmutableDictionary<I>, t
 /** Modify the values of a set of entries using a transformer. */
 export declare function mapEntries<K, I, O>(entries: Iterable<Entry<K, I>>, transformer: Transformer<I, O>): Iterable<Entry<K, O>>;
 /** Set of named transformers for a data object (or `undefined` to skip the transform). */
-export declare type Transformers<T extends ImmutableObject> = {
+export type Transformers<T extends ImmutableObject> = {
     readonly [K in keyof T]?: Transformer<T[K], T[K]> | undefined;
 };
 /** Transform an object using a set of named transformers. */

package/util/units.d.ts

@@ -1,13 +1,12 @@
 import { ImmutableObject } from "./object.js";
-import { PossibleDate } from "./date.js";
-import { MapKey, ImmutableRequiredMap } from "./map.js";
-/** Conversion from one unit to another (either a number to multiple by, or a function to convert). */
-declare type Conversion = number | ((num: number) => number);
+import { MapKey, ImmutableMap } from "./map.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. */
-declare type Conversions<T extends string> = {
+type Conversions<T extends string> = {
     readonly [K in T]?: Conversion;
 };
-declare type UnitProps<T extends string> = {
+type UnitProps<T extends string> = {
     /** Short abbreviation for this unit, e.g. `km` (defaults to first letter of `id`). */
     readonly abbr?: string;
     /** Singular name for this unit, e.g. `kilometer` (defaults to `id` + "s"). */
@@ -20,12 +19,12 @@ declare type UnitProps<T extends string> = {
     readonly to?: Conversions<T>;
 };
 /** Represent a unit. */
-export declare class Unit<T extends string> {
+export declare class Unit<K extends string> {
     /** `UnitList` this unit belongs to. */
-    readonly list: UnitList<T>;
+    readonly list: UnitList<K>;
     private readonly _to;
-    /** Identifier for this unit, e.g. `kilometer` */
-    readonly id: T;
+    /** String key for this unit, e.g. `kilometer` */
+    readonly key: K;
     /** Short abbreviation for this unit, e.g. `km` (defaults to first letter of `id`). */
     readonly abbr: string;
     /** Singular name for this unit, e.g. `kilometer` (defaults to `id`). */
@@ -38,73 +37,63 @@ export declare class Unit<T extends string> {
     get title(): string;
     constructor(
     /** `UnitList` this unit belongs to. */
-    list: UnitList<T>, 
-    /** Key for this unit, e.g. `kilometer` */
-    id: T, 
+    list: UnitList<K>, 
+    /** String key for this unit, e.g. `kilometer` */
+    key: K, 
     /** Props to configure this unit. */
-    { abbr, singular, plural, precision, to }: UnitProps<T>);
+    { abbr, singular, plural, precision, to }: UnitProps<K>);
     /** Convert an amount from this unit to another unit. */
-    to(amount: number, id?: T | Unit<T>): number;
+    to(amount: number, unit?: K | Unit<K>): number;
     /** Convert an amount from another unit to this unit. */
-    from(amount: number, id?: T | Unit<T>): number;
+    from(amount: number, unit?: K | Unit<K>): number;
     /** Convert an amount from this unit to another unit (must specify another `Unit` instance). */
     private _toUnit;
-    /** Format a number with a given unit of measure, e.g. `12 kg` or `29.5 l` */
+    /** 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 a number with a given unit of measure, e.g. `12 kilograms` or `29.5 liters` or `1 degree` */
+    /** 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;
 }
-/** Represent a list of units. */
-export declare class UnitList<T extends string> extends ImmutableRequiredMap<T, Unit<T>> {
-    readonly base: Unit<T>;
-    constructor(units: ImmutableObject<T, UnitProps<T>>);
+/**
+ * Represent a list of units.
+ * - Has a known base unit at `.base`
+ * - Cannot have additional units added after it is created.
+ */
+export declare class UnitList<K extends string> extends ImmutableMap<K, Unit<K>> {
+    readonly base: Unit<K>;
+    constructor(units: ImmutableObject<K, UnitProps<K>>);
+    /** Convert an amount from a unit to another unit. */
+    convert(amount: number, sourceUnit: K | Unit<K>, targetUnit: K | Unit<K>): number;
 }
 /** Percentage units. */
 export declare const PERCENTAGE_UNITS: UnitList<"percent">;
-export declare type PercentageUnitIdentifier = MapKey<typeof PERCENTAGE_UNITS>;
+export type PercentageUnitKey = MapKey<typeof PERCENTAGE_UNITS>;
 /** Point units. */
 export declare const POINT_UNITS: UnitList<"basis-point" | "percentage-point">;
-export declare type PointUnitIdentifier = MapKey<typeof POINT_UNITS>;
+export type PointUnitKey = MapKey<typeof POINT_UNITS>;
 /** Angle units. */
 export declare const ANGLE_UNITS: UnitList<"degree" | "radian" | "gradian">;
-export declare type AngleUnitIdentifier = MapKey<typeof ANGLE_UNITS>;
+export type AngleUnitKey = MapKey<typeof ANGLE_UNITS>;
 /** Mass units. */
 export declare const MASS_UNITS: UnitList<"milligram" | "gram" | "kilogram" | "ounce" | "pound" | "stone">;
-export declare type MassUnitIdentifier = MapKey<typeof MASS_UNITS>;
+export type MassUnitKey = MapKey<typeof MASS_UNITS>;
 /** Time units. */
 export declare const TIME_UNITS: UnitList<"millisecond" | "second" | "minute" | "hour" | "day" | "week" | "month" | "year">;
-export declare type TimeUnitIdentifier = MapKey<typeof TIME_UNITS>;
+export type TimeUnitKey = MapKey<typeof TIME_UNITS>;
 /** Length units. */
 export declare const LENGTH_UNITS: UnitList<"millimeter" | "centimeter" | "meter" | "kilometer" | "inch" | "foot" | "yard" | "furlong" | "mile">;
-export declare type LengthUnitIdentifier = MapKey<typeof LENGTH_UNITS>;
+export type LengthUnitKey = MapKey<typeof LENGTH_UNITS>;
 /** Speed units. */
 export declare const SPEED_UNITS: UnitList<"meter-per-second" | "kilometer-per-hour" | "mile-per-hour">;
-export declare type SpeedUnitIdentifier = MapKey<typeof SPEED_UNITS>;
+export type SpeedUnitKey = MapKey<typeof SPEED_UNITS>;
 /** Area units. */
 export declare const AREA_UNITS: UnitList<"square-millimeter" | "square-centimeter" | "square-meter" | "square-kilometer" | "hectare" | "square-inch" | "square-foot" | "square-yard" | "acre">;
-export declare type AreaUnitIdentifier = MapKey<typeof AREA_UNITS>;
+export type AreaUnitKey = MapKey<typeof AREA_UNITS>;
 /** Volume units. */
 export declare const VOLUME_UNITS: UnitList<"milliliter" | "liter" | "cubic-centimeter" | "cubic-meter" | "us-fluid-ounce" | "us-pint" | "us-quart" | "us-gallon" | "imperial-fluid-ounce" | "imperial-pint" | "imperial-quart" | "imperial-gallon" | "cubic-inch" | "cubic-foot" | "cubic-yard">;
-export declare type VolumeUnitIdentifier = MapKey<typeof VOLUME_UNITS>;
+export type VolumeUnitKey = MapKey<typeof VOLUME_UNITS>;
 /** Temperature units. */
 export declare const TEMPERATURE_UNITS: UnitList<"celsius" | "fahrenheit" | "kelvin">;
-export declare type TemperatureUnitIdentifier = MapKey<typeof TEMPERATURE_UNITS>;
-/** Format a percentage (combines `getPercent()` and `formatUnits()` for convenience). */
-export declare const formatPercent: (numerator: number, denumerator: number, precision?: number) => string;
-/** 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, precision?: 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, precision?: 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;
-/** 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;
-/** 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;
-/** Compact when a date will happen, e.g. `10d` or `2h` or `-1w` */
-export declare const formatAgo: (target: PossibleDate, current?: PossibleDate) => string;
+export type TemperatureUnitKey = MapKey<typeof TEMPERATURE_UNITS>;
 export {};