@weasel-js/quantity 1.6.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 orochi235
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,83 @@
+# @weasel-js/quantity
+
+Numbers with a unit and a display — how they show, how a screen reader says
+them, and how typed text reads back. No React, no DOM.
+
+Part of [weasel](https://github.com/orochi235/weasel), a domain-agnostic 2D
+scene-graph canvas kit for React. See the
+[API reference](https://orochi235.github.io/weasel/api/).
+
+```sh
+npm install @weasel-js/quantity
+```
+
+## A quantity is a number, or a number with a tag
+
+```ts
+import { qty, tag, retag, fraction } from '@weasel-js/quantity';
+
+const seam = tag(1 / 12, fraction());   // { value: 0.0833…, display: { kind: 'fraction' } }
+qty(seam).text     // '1/12'
+qty(seam).spoken   // '1 over 12'
+qty(seam).html     // '<data value="0.0833…"><span data-part="numerator">1</span>/<span data-part="denominator">12</span></data>'
+qty(seam).mathml   // '<math><mfrac><mn>1</mn><mn>12</mn></mfrac></math>'
+
+retag(seam, 1 / 6) // still tagged, still a fraction
+retag(0.5, 0.25)   // a bare number stays bare
+```
+
+`Quantity` is `number | { value, unit?, display? }`. A bare number costs
+nothing; a tagged one keeps its presentation as it moves, because code that
+changes a value writes it back with `retag`. A display is plain data, so a
+tagged value survives JSON, history snapshots and `structuredClone`.
+
+`qty(q, fallback)` wraps a quantity for display. `fallback` is the display for a
+value that carries none of its own — a value's own tag wins. Nothing about the
+wrapper is stored.
+
+## Displays
+
+| Builder | Shows | Spoken |
+|---|---|---|
+| `decimal({ places })` | `1,234.57` | `1,234.57` |
+| `integer()` | `42` | `42` |
+| `compact()` | `2.00M` | `2 million` |
+| `percent()` | `25%` | `25 percent` |
+| `fraction({ maxDenominator, mixed })` | `1/12`, `1 1/2` | `1 over 12`, `1 and 1 over 2` |
+| `ratio()` | `1:12` | `1 to 12` |
+| `multiplier()` | `2.5×` | `2.5 times` |
+| `zoom()` | `150%`, `2.5x` | `150 percent`, `2.5 times` |
+| `unit('mm', { accepts })` | `12mm` | `12 millimeters` |
+| `currency('USD')` | `$12.50` | `12.50 US dollars` |
+| `duration({ style })` | `1:02:03`, `2h 5m 3s` | `1 hour, 2 minutes, 3 seconds` |
+| `bytes({ base })` | `1.2 MB`, `1 KiB` | `1.2 megabytes`, `1 kibibyte` |
+| `roman()` | `XII` | `12` |
+| `ordinal()` | `22nd` | `22nd` |
+
+Every display parses its own text back (`parseAs('1 1/2', fraction())` is
+1.5), and NaN is the answer for text it cannot read. A display whose kind is
+not registered shows as `decimal` and keeps its tag, so a document saved by an
+app with a custom kind still opens in one without it.
+
+## Adding a kind
+
+```ts
+import { registerDisplayKind, fractionKind } from '@weasel-js/quantity';
+
+registerDisplayKind({ kind: 'hex', format: (v) => [{ type: 'number', value: `0x${v.toString(16)}` }] });
+registerDisplayKind({ ...fractionKind, speak: (v) => toWords(v) }); // replaces the built-in
+```
+
+A kind returns parts — `{ type, value }` runs, the way `Intl`'s
+`formatToParts` does. The text is the parts joined; the HTML wraps each
+non-literal part in a `<span data-part>`, which is the whole styling surface.
+
+## Units
+
+`UnitSystem` tables convert between units of one dimension (`METRIC_MM`,
+`IMPERIAL_INCHES`, `ANGLE_RADIANS`, `PIXELS`). `qty(tag(12, unit(), 'mm')).to('cm', METRIC_MM)`
+is `1.2cm`. `parseNumber('5ft 3in', { in: 1, ft: 12 })` is 63.
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,430 @@
+/**
+ * Units — a tiny customizable unit system.
+ *
+ * The kit stores all coordinates as bare numbers in a single base unit
+ * chosen by the consumer app. To make API call sites self-documenting,
+ * the public surface accepts `UnitValue` — either a bare number (interpreted
+ * as base units) or a `{ value, unit }` tag that's resolved against a
+ * `UnitSystem` at the API boundary. Internals never see units.
+ *
+ * An entry is affine — `base = value * factor + offset` — so a scale that
+ * puts zero somewhere else (degC against K) is expressible. No per-axis
+ * units. No mixed-unit arithmetic.
+ */
+/** A unit name (e.g. `'in'`, `'ft'`, `'mm'`). Looked up in a `UnitSystem`. */
+type Unit = string;
+/** What one unit is worth in base units: `base = value * factor + offset`. */
+interface UnitScale {
+    factor: number;
+    /** Where this unit puts zero, in base units. Absent is 0 — a pure scale. */
+    offset?: number;
+}
+/** One unit's conversion. A bare number is the `{ factor }` shorthand. */
+type UnitEntry = number | UnitScale;
+/** Conversion table mapping unit names to their scale against a base unit. */
+interface UnitSystem {
+    /** Name of the base unit, e.g. 'in'. All conversions resolve to this. */
+    base: Unit;
+    /** How to reach base units from each unit. The base unit's entry is 1. */
+    units: Record<Unit, UnitEntry>;
+}
+/**
+ * One unit's scale, with the bare-number shorthand widened and the offset
+ * defaulted — what every conversion in the kit reads. Throws if the system
+ * does not carry the unit.
+ */
+declare function unitScale(unitSystem: UnitSystem, unit: Unit): Required<UnitScale>;
+/** An entry's scale, with the bare-number shorthand widened and the offset defaulted. */
+declare function entryScale(entry: UnitEntry): Required<UnitScale>;
+/** Value at a unit-aware API boundary: bare number (in base units) or `{ value, unit }` tag. */
+type UnitValue = number | {
+    value: number;
+    unit: Unit;
+};
+/**
+ * Resolve a UnitValue to a number in base units.
+ *  - bare number, or a quantity tagged with no unit: its value, as base
+ *  - tagged: looks up factor; throws if unit not in unit system
+ */
+declare function resolveUnit(v: UnitValue | Quantity, unitSystem?: UnitSystem): number;
+/**
+ * Format a base-unit number as a string in the named display unit.
+ *  e.g. formatUnit(36, 'ft', IMPERIAL_INCHES) => '3ft'
+ *  Default precision: 2. Trailing zeros trimmed.
+ */
+declare function formatUnit(baseValue: number, displayUnit: Unit, unitSystem: UnitSystem, opts?: {
+    precision?: number;
+    suffix?: boolean;
+}): string;
+/** Imperial unit system with base 'in'. */
+declare const IMPERIAL_INCHES: UnitSystem;
+/** Metric unit system with base 'mm'. */
+declare const METRIC_MM: UnitSystem;
+/** Angle unit system with base 'rad'. */
+declare const ANGLE_RADIANS: UnitSystem;
+/** Pixel unit system — sole unit is the base. */
+declare const PIXELS: UnitSystem;
+
+/**
+ * How a number shows, speaks and reads back, as plain data: `{ kind: 'fraction',
+ * maxDenominator: 64 }`. Data rather than a function so a tagged value keeps its
+ * presentation through JSON, history snapshots and `structuredClone`. The
+ * behavior lives on the registered {@link DisplayKind} of the same `kind`.
+ */
+interface Display {
+    readonly kind: string;
+    readonly [option: string]: unknown;
+}
+/** A number that carries its unit, its display, or both. */
+interface Tagged {
+    value: number;
+    /** The unit `value` is measured in. Absent is the base unit. */
+    unit?: Unit;
+    display?: Display;
+}
+/**
+ * A number anywhere the engine takes one: bare, which costs nothing, or
+ * {@link Tagged}, which keeps its unit and display as it moves. Every reader
+ * goes through {@link amount}, and every writer through {@link retag}, so a
+ * value leaves in the shape it arrived in.
+ */
+type Quantity = number | Tagged;
+/** The number a quantity holds. */
+declare function amount(q: Quantity): number;
+/**
+ * `next` in the shape of `q`: a bare number stays bare, and a tagged one keeps
+ * its unit and display. What an editor calls when it changes a value it was
+ * handed, so the presentation survives the edit.
+ */
+declare function retag<Q extends Quantity>(q: Q, next: number): Q;
+/** A tagged quantity. `display` and `unit` are left off when absent, so the
+ *  JSON carries only what was set. */
+declare function tag(value: number, display?: Display, unit?: Unit): Tagged;
+/** The display `q` carries, else `fallback`. A value's own tag wins over the
+ *  default of whatever shows it. */
+declare function displayOf(q: Quantity, fallback?: Display): Display | undefined;
+/** The unit `q` is measured in, when it says. */
+declare function unitOf(q: Quantity): Unit | undefined;
+
+/**
+ * One run of a formatted value, named for what it is: `number`, `unit`,
+ * `currency`, `numerator`, `literal`. The HTML serialization marks each
+ * non-literal run with `data-part`, which is the whole styling surface.
+ */
+interface Part {
+    type: string;
+    value: string;
+}
+/** What formatting and parsing need beyond the value and its display. */
+interface FormatContext {
+    /** BCP 47 locale. Every kind parses `en-US` text, so it is the default. */
+    locale: string;
+    /** The unit the value is measured in, from its tag. */
+    unit?: Unit;
+}
+/**
+ * The behavior behind one `Display.kind`. `format` is required; `speak`
+ * defaults to the formatted text, `parse` to `parseNumber`, and `mathml` to
+ * nothing, which means the kind has no MathML form.
+ */
+interface DisplayKind<D extends Display = Display> {
+    kind: D['kind'];
+    format(value: number, display: D, ctx: FormatContext): Part[];
+    speak?(value: number, display: D, ctx: FormatContext): string;
+    parse?(text: string, display: D, ctx: FormatContext): number;
+    mathml?(value: number, display: D, ctx: FormatContext): string | undefined;
+}
+/** Parts joined into plain text. */
+declare function textOf(parts: readonly Part[]): string;
+/** A number run from `Intl`, with the real minus sign. */
+declare function numberPart(value: number, locale: string, options?: Intl.NumberFormatOptions): Part;
+/** `-` swapped for {@link MINUS_SIGN} at the front of already-formatted text. */
+declare function signed(text: string): string;
+/** A leading minus sign read aloud: `−3` is spoken `minus 3`, which a screen
+ *  reader otherwise renders as a dash or drops. */
+declare function spokenSign(text: string): string;
+/** `singular` or `plural` for `value`, by the locale's plural rules. */
+declare function plural(value: number, locale: string, singular: string, pluralForm: string): string;
+/**
+ * `Intl.NumberFormat`'s parts, with the digit runs — sign, integer, group,
+ * decimal, fraction — merged into one `number` part, so a styling layer sees
+ * the number as one thing and its unit or symbol as another.
+ */
+declare function intlParts(value: number, locale: string, options: Intl.NumberFormatOptions): Part[];
+
+/**
+ * Adds a display kind, or replaces a built-in one — the way to swap in a words
+ * library for `fraction`'s spoken form (`{ ...fractionKind, speak }`). Returns
+ * a function that removes it again.
+ */
+declare function registerDisplayKind<D extends Display>(kind: DisplayKind<D>): () => void;
+/**
+ * The kind behind `display`. An unknown kind resolves to `decimal` rather than
+ * throwing: a document saved by an app with a custom kind still opens in one
+ * without it, and its tag survives untouched.
+ */
+declare function displayKindOf(display: Display | undefined): DisplayKind<Display>;
+/** Options for presenting or parsing a quantity. */
+interface PresentOptions {
+    /** BCP 47 locale. Default `en-US`, which every kind parses. */
+    locale?: string;
+}
+/** A quantity as text, spoken text, HTML and, where its kind has one, MathML. */
+interface Presentation {
+    text: string;
+    spoken: string;
+    /** Unstyled: a `<data value>` wrapping one `<span data-part>` per named part. */
+    html: string;
+    mathml?: string;
+}
+/** Parts as the unstyled HTML fragment {@link Presentation.html} describes. */
+declare function partsToHtml(value: number, parts: readonly Part[]): string;
+/** Parts of `q` under its own display, else `fallback`, else `decimal`. */
+declare function partsOf(q: Quantity, fallback?: Display, options?: PresentOptions): Part[];
+/** `q` as text, spoken text, HTML and MathML. See {@link qty} for one at a time. */
+declare function present(q: Quantity, fallback?: Display, options?: PresentOptions): Presentation;
+/** Typed text read through `display`: NaN when it does not read. */
+declare function parseAs(text: string, display?: Display, options?: PresentOptions & {
+    unit?: Unit;
+}): number;
+/**
+ * A short-lived view of a quantity with its presentation as methods. Nothing
+ * about it is stored — keep the quantity, and wrap it where it is shown.
+ */
+declare class QuantityView<Q extends Quantity = Quantity> {
+    /** The quantity as given. */
+    readonly raw: Q;
+    private readonly fallback?;
+    private readonly options?;
+    constructor(
+    /** The quantity as given. */
+    raw: Q, fallback?: Display | undefined, options?: PresentOptions | undefined);
+    get value(): number;
+    get unit(): Unit | undefined;
+    /** The display in effect: the value's own, else the fallback. */
+    get display(): Display | undefined;
+    get parts(): Part[];
+    get text(): string;
+    get spoken(): string;
+    get html(): string;
+    get mathml(): string | undefined;
+    /** `next` in this quantity's shape — see {@link retag}. */
+    with(next: number): QuantityView<Q>;
+    /** Typed text read through this quantity's display; NaN when it does not read. */
+    parse(text: string): number;
+    /** The same amount in `target`, converted through `system`, tagged with it. */
+    to(target: Unit, system: UnitSystem): QuantityView;
+    toJSON(): Q;
+}
+/** Wraps `q` for display: `qty(band.from, fraction()).text`. `fallback` is the
+ *  display for a value that carries none of its own. */
+declare function qty<Q extends Quantity>(q: Q, fallback?: Display, options?: PresentOptions): QuantityView<Q>;
+
+/** A plain number. `places` fixes the decimals, trailing zeros included;
+ *  otherwise up to `maxPlaces` (default 3) show and trailing zeros drop. */
+type DecimalDisplay = {
+    kind: 'decimal';
+    places?: number;
+    maxPlaces?: number;
+    /** Thousands separators. Default true. */
+    grouping?: boolean;
+};
+declare function decimal(options?: Omit<DecimalDisplay, 'kind'>): DecimalDisplay;
+declare const decimalKind: DisplayKind<DecimalDisplay>;
+/** A whole number, rounded. */
+type IntegerDisplay = {
+    kind: 'integer';
+    grouping?: boolean;
+};
+declare function integer(options?: Omit<IntegerDisplay, 'kind'>): IntegerDisplay;
+declare const integerKind: DisplayKind<IntegerDisplay>;
+/**
+ * Below 1,000 at `places` decimals, from 1,000 up at three significant figures
+ * with a magnitude suffix (`40.0K`, `2.00M`), so a readout holds one width.
+ * Spoken long: `2 million`.
+ */
+type CompactDisplay = {
+    kind: 'compact';
+    places?: number;
+};
+declare function compact(options?: Omit<CompactDisplay, 'kind'>): CompactDisplay;
+declare const compactKind: DisplayKind<CompactDisplay>;
+
+/** A share of one as a percentage: 0.25 shows `25%`. Typed text reads as
+ *  percent with or without the sign. */
+type PercentDisplay = {
+    kind: 'percent';
+    /** Most decimals shown. Default 0. */
+    places?: number;
+};
+declare function percent(options?: Omit<PercentDisplay, 'kind'>): PercentDisplay;
+declare const percentKind: DisplayKind<PercentDisplay>;
+/**
+ * The nearest fraction whose denominator is at most `maxDenominator`, as
+ * `[numerator, denominator]` in lowest terms with the sign on the numerator.
+ * Walks the continued fraction and settles the last step on the best
+ * semiconvergent, which is the closest any denominator in range can get.
+ */
+declare function nearestFraction(x: number, maxDenominator: number): [number, number];
+/**
+ * A value as the nearest fraction: 1/12 shows `1/12` and is spoken `1 over 12`.
+ * `mixed` splits a whole part off (`1 1/2`); a whole value shows as an integer.
+ * Has a MathML form, as `<mfrac>`.
+ */
+type FractionDisplay = {
+    kind: 'fraction';
+    /** Default 64. */
+    maxDenominator?: number;
+    mixed?: boolean;
+};
+declare function fraction(options?: Omit<FractionDisplay, 'kind'>): FractionDisplay;
+declare const fractionKind: DisplayKind<FractionDisplay>;
+/** A value as a ratio `a:b` — 1/12 shows `1:12`, spoken `1 to 12`. */
+type RatioDisplay = {
+    kind: 'ratio';
+    /** Largest second term. Default 64. */
+    maxDenominator?: number;
+};
+declare function ratio(options?: Omit<RatioDisplay, 'kind'>): RatioDisplay;
+declare const ratioKind: DisplayKind<RatioDisplay>;
+/** A factor with a times sign: `2.5×`, spoken `2.5 times`. Typed `x` reads too. */
+type MultiplierDisplay = {
+    kind: 'multiplier';
+    /** Most decimals. Default 2. */
+    places?: number;
+    /** Default `×`. */
+    symbol?: string;
+};
+declare function multiplier(options?: Omit<MultiplierDisplay, 'kind'>): MultiplierDisplay;
+declare const multiplierKind: DisplayKind<MultiplierDisplay>;
+/**
+ * A zoom factor. At 2x and below a percentage reads naturally; past it a
+ * multiplier is what people say, so 2.5 shows `2.5x`. Past 100x a tenth is
+ * noise: `1009.74` shows `1,010x`. Typed text without a sign reads as percent.
+ */
+type ZoomDisplay = {
+    kind: 'zoom';
+};
+declare function zoom(): ZoomDisplay;
+declare const zoomKind: DisplayKind<ZoomDisplay>;
+
+/**
+ * Display-formatter for numbers. Use this anywhere a number is shown to
+ * a user. The whole point: negative values get prefixed with the real
+ * MINUS SIGN (U+2212) instead of the ASCII HYPHEN-MINUS (U+002D) that
+ * `toLocaleString` and template literals produce by default.
+ *
+ * U+2212 is the same visual width as `+` and reads as a sign rather
+ * than a hyphen — columns of signed numbers align cleanly and the
+ * glyph doesn't get confused with a bullet or list dash.
+ */
+declare const MINUS_SIGN = "\u2212";
+/**
+ * Formats a number for display, substituting {@link MINUS_SIGN} for the ASCII
+ * hyphen `toLocaleString` emits. Non-finite values stringify as-is.
+ */
+declare function formatNumber(value: number, options?: Intl.NumberFormatOptions): string;
+/**
+ * Parses a string that may carry {@link MINUS_SIGN} in place of the ASCII
+ * hyphen. The inverse of {@link formatNumber} for any editing surface that
+ * renders its value through it and reads the edited text back.
+ */
+declare function parseSignedNumber(text: string): number;
+/**
+ * Formats a number the way a `compact` readout shows it: below 1,000 at
+ * `decimals` places, from 1,000 up at three significant figures with a magnitude
+ * suffix (`40.0K`, `294K`, `2.00M`), so the readout holds one width whatever the
+ * value. Always `en-US`, so {@link parseNumber} reads it back.
+ */
+declare function formatCompact(value: number, decimals?: number): string;
+/**
+ * Reads a typed number: anything {@link parseSignedNumber} reads, plus
+ * thousands commas in the `40,000` shape and a `k`/`m`/`b`/`t` suffix in either
+ * case (`2.5m` is 2,500,000). Empty text is NaN rather than zero.
+ *
+ * Given `units` — a suffix mapped to the factor it scales by — a trailing unit
+ * name is read first: the longest match wins, exact case before any case, and
+ * a unit beats a magnitude suffix, so with `m` accepted `2m` is `2 * units.m`.
+ */
+declare function parseNumber(text: string, units?: Readonly<UnitTable>): number;
+/** Suffixes a person may type, each mapped to its conversion into the shown unit. */
+type UnitTable = Record<string, UnitEntry>;
+
+/**
+ * A number with its unit: `12mm`, spoken `12 millimeters`. The unit is the
+ * display's, else the one the value is tagged with. `accepts` is what a person
+ * may type, each unit mapped to its conversion into the shown one; compound
+ * text such as `5ft 3in` reads when every term's unit is accepted.
+ */
+type UnitDisplay = {
+    kind: 'unit';
+    unit?: string;
+    /** Most decimals, trailing zeros dropped. Default 2. */
+    places?: number;
+    /** A space between number and unit. Default false. */
+    space?: boolean;
+    accepts?: UnitTable;
+    /** Singular and plural names, for a unit `Intl` cannot name. */
+    spoken?: readonly [string, string];
+};
+declare function unit(name?: string, options?: Omit<UnitDisplay, 'kind' | 'unit'>): UnitDisplay;
+declare const unitKind: DisplayKind<UnitDisplay>;
+/** Money in an ISO 4217 currency: `$12.50`, spoken `12.50 US dollars`. */
+type CurrencyDisplay = {
+    kind: 'currency';
+    currency: string;
+    /** Fixed decimals. Defaults to the currency's own (2 for USD, 0 for JPY). */
+    places?: number;
+};
+declare function currency(code: string, options?: Omit<CurrencyDisplay, 'kind' | 'currency'>): CurrencyDisplay;
+declare const currencyKind: DisplayKind<CurrencyDisplay>;
+/**
+ * A span of time, the value in seconds. `clock` shows `1:02:03` or `4:05.5`;
+ * `units` shows `2h 5m 3s`. Spoken `2 hours, 5 minutes, 3 seconds`. Typed text
+ * reads in either form.
+ */
+type DurationDisplay = {
+    kind: 'duration';
+    /** Default `'clock'`. */
+    style?: 'clock' | 'units';
+    /** Decimals on the seconds. Default 0. */
+    places?: number;
+};
+declare function duration(options?: Omit<DurationDisplay, 'kind'>): DurationDisplay;
+declare const durationKind: DisplayKind<DurationDisplay>;
+/** A byte count in the largest unit that keeps it at or above 1: `1.2 MB`,
+ *  spoken `1.2 megabytes`. `base: 1024` uses `KiB`, `MiB`, … */
+type BytesDisplay = {
+    kind: 'bytes';
+    /** Default 1000. */
+    base?: 1000 | 1024;
+    /** Most decimals. Default 1. */
+    places?: number;
+};
+declare function bytes(options?: Omit<BytesDisplay, 'kind'>): BytesDisplay;
+declare const bytesKind: DisplayKind<BytesDisplay>;
+
+/**
+ * A whole number in Roman numerals, `XII`. Spoken as the plain number, since a
+ * screen reader otherwise spells the letters out. Outside 1–3999, which the
+ * numerals cannot write, it shows as a plain number.
+ */
+type RomanDisplay = {
+    kind: 'roman';
+    lower?: boolean;
+};
+declare function roman(options?: Omit<RomanDisplay, 'kind'>): RomanDisplay;
+/** `n` in Roman numerals, or undefined outside 1–3999. */
+declare function toRoman(n: number): string | undefined;
+/** The value of well-formed Roman numerals, either case; NaN otherwise. */
+declare function fromRoman(text: string): number;
+declare const romanKind: DisplayKind<RomanDisplay>;
+/** A whole number as an ordinal: `1st`, `22nd`, `113th`. English suffixes;
+ *  in any other locale the number shows alone. */
+type OrdinalDisplay = {
+    kind: 'ordinal';
+};
+declare function ordinal(): OrdinalDisplay;
+declare const ordinalKind: DisplayKind<OrdinalDisplay>;
+
+export { ANGLE_RADIANS, type BytesDisplay, type CompactDisplay, type CurrencyDisplay, type DecimalDisplay, type Display, type DisplayKind, type DurationDisplay, type FormatContext, type FractionDisplay, IMPERIAL_INCHES, type IntegerDisplay, METRIC_MM, MINUS_SIGN, type MultiplierDisplay, type OrdinalDisplay, PIXELS, type Part, type PercentDisplay, type PresentOptions, type Presentation, type Quantity, QuantityView, type RatioDisplay, type RomanDisplay, type Tagged, type Unit, type UnitDisplay, type UnitEntry, type UnitScale, type UnitSystem, type UnitTable, type UnitValue, type ZoomDisplay, amount, bytes, bytesKind, compact, compactKind, currency, currencyKind, decimal, decimalKind, displayKindOf, displayOf, duration, durationKind, entryScale, formatCompact, formatNumber, formatUnit, fraction, fractionKind, fromRoman, integer, integerKind, intlParts, multiplier, multiplierKind, nearestFraction, numberPart, ordinal, ordinalKind, parseAs, parseNumber, parseSignedNumber, partsOf, partsToHtml, percent, percentKind, plural, present, qty, ratio, ratioKind, registerDisplayKind, resolveUnit, retag, roman, romanKind, signed, spokenSign, tag, textOf, toRoman, unit, unitKind, unitOf, unitScale, zoom, zoomKind };