measurable 1.1.1 → 2.0.0

package/dist/dimensions/illuminance.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.microlux = exports.millilux = exports.kilolux = exports.metricIlluminance = exports.phot = exports.footCandle = exports.lux = exports.illuminance = void 0;
+const Dimension_1 = require("../lib/Dimension");
+const definePrefixed_1 = require("../utils/definePrefixed");
+/** Illuminance. Base unit: lux. */
+exports.illuminance = new Dimension_1.Dimension("illuminance");
+exports.lux = exports.illuminance.base("lux", ["lx"]);
+exports.footCandle = exports.illuminance.unit("footCandle", 10.764, ["fc", "ft-c"]);
+exports.phot = exports.illuminance.unit("phot", 10000, ["ph", "phots"]);
+/** Every SI-prefixed lux (kilolux, millilux, microlux, …), keyed by name. */
+exports.metricIlluminance = (0, definePrefixed_1.definePrefixed)(exports.illuminance, { name: "lux", symbol: "lx" });
+exports.kilolux = exports.metricIlluminance.kilolux, exports.millilux = exports.metricIlluminance.millilux, exports.microlux = exports.metricIlluminance.microlux;

package/dist/dimensions/index.d.ts

@@ -1,7 +1,16 @@
 export * from "./angle";
+export * from "./area";
+export * from "./data";
+export * from "./energy";
 export * from "./force";
+export * from "./frequency";
+export * from "./illuminance";
 export * from "./length";
+export * from "./luminance";
+export * from "./luminousIntensity";
 export * from "./mass";
+export * from "./power";
+export * from "./pressure";
 export * from "./temperature";
 export * from "./time";
 export * from "./volume";

package/dist/dimensions/index.js

@@ -15,9 +15,18 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./angle"), exports);
+__exportStar(require("./area"), exports);
+__exportStar(require("./data"), exports);
+__exportStar(require("./energy"), exports);
 __exportStar(require("./force"), exports);
+__exportStar(require("./frequency"), exports);
+__exportStar(require("./illuminance"), exports);
 __exportStar(require("./length"), exports);
+__exportStar(require("./luminance"), exports);
+__exportStar(require("./luminousIntensity"), exports);
 __exportStar(require("./mass"), exports);
+__exportStar(require("./power"), exports);
+__exportStar(require("./pressure"), exports);
 __exportStar(require("./temperature"), exports);
 __exportStar(require("./time"), exports);
 __exportStar(require("./volume"), exports);

package/dist/dimensions/length.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.nanometer = exports.micrometer = exports.millimeter = exports.centimeter = exports.decimeter = exports.decameter = exports.hectometer = exports.kilometer = exports.metricLength = exports.mile = exports.yard = exports.foot = exports.inch = exports.meter = exports.length = void 0;
 const Dimension_1 = require("../lib/Dimension");
-const prefixes_1 = require("../lib/prefixes");
+const definePrefixed_1 = require("../utils/definePrefixed");
 /** Length / distance. Base unit: meter. */
 exports.length = new Dimension_1.Dimension("length");
 exports.meter = exports.length.base("meter", ["m", "meters"]);
@@ -12,5 +12,5 @@ exports.foot = exports.length.unit("foot", 0.3048, ["ft", "feet"]);
 exports.yard = exports.length.unit("yard", 0.9144, ["yd", "yards"]);
 exports.mile = exports.length.unit("mile", 1609.344, ["mi", "miles"]);
 /** Every SI-prefixed meter (kilometer, centimeter, micrometer, …), keyed by name. */
-exports.metricLength = (0, prefixes_1.definePrefixed)(exports.length, { name: "meter", symbol: "m", scale: 1 });
+exports.metricLength = (0, definePrefixed_1.definePrefixed)(exports.length, { name: "meter", symbol: "m" });
 exports.kilometer = exports.metricLength.kilometer, exports.hectometer = exports.metricLength.hectometer, exports.decameter = exports.metricLength.decameter, exports.decimeter = exports.metricLength.decimeter, exports.centimeter = exports.metricLength.centimeter, exports.millimeter = exports.metricLength.millimeter, exports.micrometer = exports.metricLength.micrometer, exports.nanometer = exports.metricLength.nanometer;

package/dist/dimensions/luminance.d.ts

@@ -0,0 +1,7 @@
+import { Dimension } from "../lib/Dimension";
+/** Luminance. Base unit: candela per square meter (the nit). */
+export declare const luminance: Dimension;
+export declare const candelaPerSquareMeter: import("..").Unit;
+export declare const stilb: import("..").Unit;
+/** Alias for {@link candelaPerSquareMeter}. */
+export declare const nit: import("..").Unit;

package/dist/dimensions/luminance.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nit = exports.stilb = exports.candelaPerSquareMeter = exports.luminance = void 0;
+const Dimension_1 = require("../lib/Dimension");
+/** Luminance. Base unit: candela per square meter (the nit). */
+exports.luminance = new Dimension_1.Dimension("luminance");
+exports.candelaPerSquareMeter = exports.luminance.base("candelaPerSquareMeter", [
+    "cd/m²",
+    "cd/m2",
+    "nit",
+    "nits",
+    "nt",
+]);
+exports.stilb = exports.luminance.unit("stilb", 1e4, ["sb"]);
+/** Alias for {@link candelaPerSquareMeter}. */
+exports.nit = exports.candelaPerSquareMeter;

package/dist/dimensions/luminousIntensity.d.ts

@@ -0,0 +1,9 @@
+import { Dimension } from "../lib/Dimension";
+/** Luminous intensity. Base unit: candela. */
+export declare const luminousIntensity: Dimension;
+export declare const candela: import("..").Unit;
+export declare const candlepower: import("..").Unit;
+export declare const hefnerkerze: import("..").Unit;
+/** Every SI-prefixed candela (kilocandela, millicandela, …), keyed by name. */
+export declare const metricLuminousIntensity: Record<string, import("..").Unit>;
+export declare const kilocandela: import("..").Unit, millicandela: import("..").Unit, microcandela: import("..").Unit;

package/dist/dimensions/luminousIntensity.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.microcandela = exports.millicandela = exports.kilocandela = exports.metricLuminousIntensity = exports.hefnerkerze = exports.candlepower = exports.candela = exports.luminousIntensity = void 0;
+const Dimension_1 = require("../lib/Dimension");
+const definePrefixed_1 = require("../utils/definePrefixed");
+/** Luminous intensity. Base unit: candela. */
+exports.luminousIntensity = new Dimension_1.Dimension("luminousIntensity");
+exports.candela = exports.luminousIntensity.base("candela", ["cd"]);
+exports.candlepower = exports.luminousIntensity.unit("candlepower", 1, ["cp", "CP"]);
+exports.hefnerkerze = exports.luminousIntensity.unit("hefnerkerze", 0.92, ["HK"]);
+/** Every SI-prefixed candela (kilocandela, millicandela, …), keyed by name. */
+exports.metricLuminousIntensity = (0, definePrefixed_1.definePrefixed)(exports.luminousIntensity, {
+    name: "candela",
+    symbol: "cd",
+});
+exports.kilocandela = exports.metricLuminousIntensity.kilocandela, exports.millicandela = exports.metricLuminousIntensity.millicandela, exports.microcandela = exports.metricLuminousIntensity.microcandela;

package/dist/dimensions/mass.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.nanogram = exports.microgram = exports.milligram = exports.centigram = exports.decigram = exports.decagram = exports.hectogram = exports.megagram = exports.kilogram = exports.metricMass = exports.longTon = exports.shortTon = exports.tonne = exports.stone = exports.ounce = exports.pound = exports.gram = exports.mass = void 0;
 const Dimension_1 = require("../lib/Dimension");
-const prefixes_1 = require("../lib/prefixes");
+const definePrefixed_1 = require("../utils/definePrefixed");
 /**
  * Mass / weight. Base unit: gram. (SI's official base is the kilogram, but
  * prefixes attach to the gram, so gram is the natural routing anchor — the
@@ -20,5 +20,5 @@ exports.tonne = exports.mass.unit("tonne", 1000000, ["t", "tonnes"]);
 exports.shortTon = exports.mass.unit("shortTon", 907184.74, ["ton", "tons"]);
 exports.longTon = exports.mass.unit("longTon", 1016046.9088, ["ton", "tons"]);
 /** Every SI-prefixed gram — including the kilogram — keyed by name. */
-exports.metricMass = (0, prefixes_1.definePrefixed)(exports.mass, { name: "gram", symbol: "g", scale: 1 });
+exports.metricMass = (0, definePrefixed_1.definePrefixed)(exports.mass, { name: "gram", symbol: "g" });
 exports.kilogram = exports.metricMass.kilogram, exports.megagram = exports.metricMass.megagram, exports.hectogram = exports.metricMass.hectogram, exports.decagram = exports.metricMass.decagram, exports.decigram = exports.metricMass.decigram, exports.centigram = exports.metricMass.centigram, exports.milligram = exports.metricMass.milligram, exports.microgram = exports.metricMass.microgram, exports.nanogram = exports.metricMass.nanogram;

package/dist/dimensions/power.d.ts

@@ -0,0 +1,9 @@
+import { Dimension } from "../lib/Dimension";
+/** Power. Base unit: watt. */
+export declare const power: Dimension;
+export declare const watt: import("..").Unit;
+export declare const horsepower: import("..").Unit;
+export declare const metricHorsepower: import("..").Unit;
+/** Every SI-prefixed watt (kilowatt, megawatt, gigawatt, milliwatt, …), keyed by name. */
+export declare const metricPower: Record<string, import("..").Unit>;
+export declare const kilowatt: import("..").Unit, megawatt: import("..").Unit, gigawatt: import("..").Unit, terawatt: import("..").Unit, milliwatt: import("..").Unit;

package/dist/dimensions/power.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.milliwatt = exports.terawatt = exports.gigawatt = exports.megawatt = exports.kilowatt = exports.metricPower = exports.metricHorsepower = exports.horsepower = exports.watt = exports.power = void 0;
+const Dimension_1 = require("../lib/Dimension");
+const definePrefixed_1 = require("../utils/definePrefixed");
+/** Power. Base unit: watt. */
+exports.power = new Dimension_1.Dimension("power");
+exports.watt = exports.power.base("watt", ["W", "watts"]);
+exports.horsepower = exports.power.unit("horsepower", 745.699872, ["hp"]);
+exports.metricHorsepower = exports.power.unit("metricHorsepower", 735.49875, ["PS"]);
+/** Every SI-prefixed watt (kilowatt, megawatt, gigawatt, milliwatt, …), keyed by name. */
+exports.metricPower = (0, definePrefixed_1.definePrefixed)(exports.power, { name: "watt", symbol: "W" });
+exports.kilowatt = exports.metricPower.kilowatt, exports.megawatt = exports.metricPower.megawatt, exports.gigawatt = exports.metricPower.gigawatt, exports.terawatt = exports.metricPower.terawatt, exports.milliwatt = exports.metricPower.milliwatt;

package/dist/dimensions/pressure.d.ts

@@ -0,0 +1,14 @@
+import { Dimension } from "../lib/Dimension";
+/** Pressure. Base unit: pascal. */
+export declare const pressure: Dimension;
+export declare const pascal: import("..").Unit;
+export declare const bar: import("..").Unit;
+export declare const millibar: import("..").Unit;
+export declare const atmosphere: import("..").Unit;
+export declare const torr: import("..").Unit;
+export declare const psi: import("..").Unit;
+export declare const inchOfMercury: import("..").Unit;
+export declare const inchOfWater: import("..").Unit;
+/** Every SI-prefixed pascal (kilopascal, hectopascal, megapascal, …), keyed by name. */
+export declare const metricPressure: Record<string, import("..").Unit>;
+export declare const kilopascal: import("..").Unit, hectopascal: import("..").Unit, megapascal: import("..").Unit, gigapascal: import("..").Unit;

package/dist/dimensions/pressure.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gigapascal = exports.megapascal = exports.hectopascal = exports.kilopascal = exports.metricPressure = exports.inchOfWater = exports.inchOfMercury = exports.psi = exports.torr = exports.atmosphere = exports.millibar = exports.bar = exports.pascal = exports.pressure = void 0;
+const Dimension_1 = require("../lib/Dimension");
+const definePrefixed_1 = require("../utils/definePrefixed");
+/** Pressure. Base unit: pascal. */
+exports.pressure = new Dimension_1.Dimension("pressure");
+exports.pascal = exports.pressure.base("pascal", ["Pa", "pascals"]);
+exports.bar = exports.pressure.unit("bar", 1e5, ["bars"]);
+exports.millibar = exports.pressure.unit("millibar", 1e2, ["mbar", "millibars"]);
+exports.atmosphere = exports.pressure.unit("atmosphere", 101325, ["atm", "atmospheres"]);
+exports.torr = exports.pressure.unit("torr", 101325 / 760, ["Torr", "torrs"]);
+exports.psi = exports.pressure.unit("psi", 6894.757293168, ["lbf/in²", "lbf/in2"]);
+exports.inchOfMercury = exports.pressure.unit("inchOfMercury", 3386.389, ["inHg"]);
+exports.inchOfWater = exports.pressure.unit("inchOfWater", 249.0889, ["inAq"]);
+/** Every SI-prefixed pascal (kilopascal, hectopascal, megapascal, …), keyed by name. */
+exports.metricPressure = (0, definePrefixed_1.definePrefixed)(exports.pressure, { name: "pascal", symbol: "Pa" });
+exports.kilopascal = exports.metricPressure.kilopascal, exports.hectopascal = exports.metricPressure.hectopascal, exports.megapascal = exports.metricPressure.megapascal, exports.gigapascal = exports.metricPressure.gigapascal;

package/dist/dimensions/temperature.js

@@ -2,11 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fahrenheit = exports.celsius = exports.kelvin = exports.temperature = void 0;
 const Dimension_1 = require("../lib/Dimension");
+const Rational_1 = require("../lib/Rational");
 /**
  * Temperature. Base unit: kelvin. Uses affine units because Celsius and
  * Fahrenheit are offset from the base, not just scaled.
  */
 exports.temperature = new Dimension_1.Dimension("temperature");
+// Fahrenheit's 5/9 ratio is not a terminating decimal, so it is given as an
+// exact Rational; the offset (273.15 − 32 × 5/9 K) is then derived in exact
+// rational arithmetic so conversions round-trip without drift.
+const fahrenheitScale = new Rational_1.Rational(5, 9);
+const fahrenheitOffset = Rational_1.Rational.from(273.15).minus(new Rational_1.Rational(32).times(fahrenheitScale));
 exports.kelvin = exports.temperature.base("kelvin", ["K"]);
 exports.celsius = exports.temperature.affine("celsius", { scale: 1, offset: 273.15 }, ["C", "°C"]);
-exports.fahrenheit = exports.temperature.affine("fahrenheit", { scale: 5 / 9, offset: 273.15 - 32 * (5 / 9) }, ["F", "°F"]);
+exports.fahrenheit = exports.temperature.affine("fahrenheit", { scale: fahrenheitScale, offset: fahrenheitOffset }, ["F", "°F"]);

package/dist/dimensions/time.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.picosecond = exports.nanosecond = exports.microsecond = exports.millisecond = exports.metricTime = exports.week = exports.day = exports.hour = exports.minute = exports.second = exports.time = void 0;
 const Dimension_1 = require("../lib/Dimension");
-const prefixes_1 = require("../lib/prefixes");
+const definePrefixed_1 = require("../utils/definePrefixed");
 /** Time / duration. Base unit: second. */
 exports.time = new Dimension_1.Dimension("time");
 exports.second = exports.time.base("second", ["s", "sec", "secs", "seconds"]);
@@ -14,5 +14,5 @@ exports.week = exports.time.unit("week", 604800, ["wk", "weeks"]);
  * SI-submultiple seconds (millisecond, microsecond, nanosecond, …). Only
  * fractions are generated; larger spans use minute/hour/day/week above.
  */
-exports.metricTime = (0, prefixes_1.definePrefixed)(exports.time, { name: "second", symbol: "s", scale: 1 }, prefixes_1.SI_SUBMULTIPLE_PREFIXES);
+exports.metricTime = (0, definePrefixed_1.definePrefixed)(exports.time, { name: "second", symbol: "s" }, definePrefixed_1.SI_SUBMULTIPLE_PREFIXES);
 exports.millisecond = exports.metricTime.millisecond, exports.microsecond = exports.metricTime.microsecond, exports.nanosecond = exports.metricTime.nanosecond, exports.picosecond = exports.metricTime.picosecond;

package/dist/dimensions/volume.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.milliliter = exports.centiliter = exports.deciliter = exports.decaliter = exports.hectoliter = exports.kiloliter = exports.metricVolume = exports.teaspoon = exports.tablespoon = exports.cup = exports.imperialFluidOunce = exports.imperialGill = exports.imperialPint = exports.imperialQuart = exports.imperialGallon = exports.usFluidOunce = exports.usGill = exports.usPint = exports.usQuart = exports.usGallon = exports.liter = exports.volume = void 0;
 const Dimension_1 = require("../lib/Dimension");
-const prefixes_1 = require("../lib/prefixes");
+const definePrefixed_1 = require("../utils/definePrefixed");
 /** Volume / capacity. Base unit: liter. */
 exports.volume = new Dimension_1.Dimension("volume");
 exports.liter = exports.volume.base("liter", ["L", "liters"]);
@@ -33,5 +33,5 @@ exports.cup = exports.volume.unit("cup", 0.2365882365, ["cups"]);
 exports.tablespoon = exports.volume.unit("tablespoon", 0.01478676478125, ["tbsp", "tablespoons"]);
 exports.teaspoon = exports.volume.unit("teaspoon", 0.00492892159375, ["tsp", "teaspoons"]);
 /** Every SI-prefixed liter (milliliter, centiliter, kiloliter, …), keyed by name. */
-exports.metricVolume = (0, prefixes_1.definePrefixed)(exports.volume, { name: "liter", symbol: "L", scale: 1 });
+exports.metricVolume = (0, definePrefixed_1.definePrefixed)(exports.volume, { name: "liter", symbol: "L" });
 exports.kiloliter = exports.metricVolume.kiloliter, exports.hectoliter = exports.metricVolume.hectoliter, exports.decaliter = exports.metricVolume.decaliter, exports.deciliter = exports.metricVolume.deciliter, exports.centiliter = exports.metricVolume.centiliter, exports.milliliter = exports.metricVolume.milliliter;

package/dist/index.d.ts

@@ -3,6 +3,7 @@ export * from "./errors/InvalidConversionError";
 export * from "./errors/UnknownUnitError";
 export * from "./lib/Dimension";
 export * from "./lib/MeasurementSystem";
-export * from "./lib/prefixes";
 export * from "./lib/Quantity";
+export * from "./lib/Rational";
 export * from "./lib/Unit";
+export * from "./utils/definePrefixed";

package/dist/index.js

@@ -19,6 +19,7 @@ __exportStar(require("./errors/InvalidConversionError"), exports);
 __exportStar(require("./errors/UnknownUnitError"), exports);
 __exportStar(require("./lib/Dimension"), exports);
 __exportStar(require("./lib/MeasurementSystem"), exports);
-__exportStar(require("./lib/prefixes"), exports);
 __exportStar(require("./lib/Quantity"), exports);
+__exportStar(require("./lib/Rational"), exports);
 __exportStar(require("./lib/Unit"), exports);
+__exportStar(require("./utils/definePrefixed"), exports);

package/dist/lib/Dimension.d.ts

@@ -1,10 +1,15 @@
+import { Rational } from "../lib/Rational";
 import { Unit } from "./Unit";
 /** A linear unit with an additive offset (e.g. temperature scales). */
 export interface AffineSpec {
-    /** Multiplier applied when converting a value to the base unit. */
-    scale: number;
+    /**
+     * Multiplier applied when converting a value to the base unit. Pass a
+     * {@link Rational} (e.g. `new Rational(5, 9)`) for ratios that a decimal
+     * cannot represent exactly.
+     */
+    scale: number | Rational;
     /** Constant added (in base units) after scaling. */
-    offset: number;
+    offset: number | Rational;
 }
 /** A fully custom transform pair for non-linear units. */
 export interface CustomSpec {
@@ -17,10 +22,14 @@ export interface CustomSpec {
  * the dimension is defined relative to, and it is the single place where all
  * conversion math happens.
  *
- * Converting `A → B` is always `B.fromBase(A.toBase(value))`: route through the
- * base unit. This gives transitive conversions for free (any unit ↔ any unit)
- * and means each unit only ever stores its relationship to the base — never a
- * redundant, drift-prone pair of factors.
+ * Converting `A → B` routes through the base unit — conceptually
+ * `B.fromBase(A.toBase(value))`. This gives transitive conversions for free
+ * (any unit ↔ any unit) and means each unit only ever stores its relationship
+ * to the base — never a redundant, drift-prone pair of factors. Linear and
+ * affine units carry that relationship as an exact {@link Rational} transform,
+ * so their conversions are done in rational arithmetic and collapsed to a float
+ * once at the end, avoiding the binary rounding of routing through the base.
+ * Only non-linear units (defined via {@link custom}) fall back to float.
  *
  * A dimension is distinct from a {@link MeasurementSystem} (metric/imperial/…):
  * the dimension decides what *can convert*, while a measurement system is a tag
@@ -42,18 +51,35 @@ export declare class Dimension {
     base(name: string, aliases?: string[]): Unit;
     /**
      * Define a linear unit. `scale` is how many base units make up one of this
-     * unit (e.g. a kilometer is `1000` meters).
+     * unit (e.g. a kilometer is `1000` meters). Pass a {@link Rational} for a
+     * scale a decimal cannot represent exactly.
      */
-    unit(name: string, scale: number, aliases?: string[]): Unit;
+    unit(name: string, scale: number | Rational, aliases?: string[]): Unit;
     /** Define an affine unit (scale plus additive offset, e.g. °C against K). */
     affine(name: string, { scale, offset }: AffineSpec, aliases?: string[]): Unit;
-    /** Define a unit with an arbitrary, hand-written inverse transform pair. */
+    /**
+     * Define a non-linear unit from an arbitrary, hand-written inverse transform
+     * pair. Reserve this for units that genuinely cannot be expressed as `value *
+     * scale + offset` — e.g. logarithmic scales (decibels, octaves). Linear and
+     * affine units should use {@link unit} / {@link affine} so conversions stay
+     * exact.
+     */
     custom(name: string, { toBase, fromBase }: CustomSpec, aliases?: string[]): Unit;
-    /** Convert a value between two units of this dimension, routed through the base. */
+    /** Convert a `number` value between two units of this dimension. */
     convert(value: number, from: Unit, to: Unit): number;
+    /**
+     * Convert an exact {@link Rational} value between two units, routed through
+     * the base. Linear / affine units stay exact end-to-end (the result is never
+     * collapsed to a float here), which is what lets {@link Quantity} chain
+     * conversions without drift. A conversion touching a non-linear `custom` unit
+     * falls back to float math and recaptures the result as a rational.
+     */
+    convertRational(value: Rational, from: Unit, to: Unit): Rational;
     /** Resolve a name or alias to its candidate unit(s) (used by parsing). */
     get(token: string): Unit[] | undefined;
     has(unit: Unit): boolean;
+    /** Define a linear / affine unit from its exact rational transform. */
+    private defineLinear;
     private define;
     /** Append a name/alias → unit mapping; shared aliases accumulate candidates. */
     private register;

package/dist/lib/Dimension.js

@@ -2,17 +2,26 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Dimension = void 0;
 const InvalidConversionError_1 = require("../errors/InvalidConversionError");
+const Rational_1 = require("../lib/Rational");
 const Unit_1 = require("./Unit");
+/** The rational `0`. */
+const zero = new Rational_1.Rational(0n);
+/** The rational `1`. */
+const one = new Rational_1.Rational(1n);
 /**
  * A dimension is a single *kind* of measurable quantity (length, volume, mass,
  * temperature, …). It owns one canonical **base unit** that every other unit in
  * the dimension is defined relative to, and it is the single place where all
  * conversion math happens.
  *
- * Converting `A → B` is always `B.fromBase(A.toBase(value))`: route through the
- * base unit. This gives transitive conversions for free (any unit ↔ any unit)
- * and means each unit only ever stores its relationship to the base — never a
- * redundant, drift-prone pair of factors.
+ * Converting `A → B` routes through the base unit — conceptually
+ * `B.fromBase(A.toBase(value))`. This gives transitive conversions for free
+ * (any unit ↔ any unit) and means each unit only ever stores its relationship
+ * to the base — never a redundant, drift-prone pair of factors. Linear and
+ * affine units carry that relationship as an exact {@link Rational} transform,
+ * so their conversions are done in rational arithmetic and collapsed to a float
+ * once at the end, avoiding the binary rounding of routing through the base.
+ * Only non-linear units (defined via {@link custom}) fall back to float.
  *
  * A dimension is distinct from a {@link MeasurementSystem} (metric/imperial/…):
  * the dimension decides what *can convert*, while a measurement system is a tag
@@ -31,34 +40,56 @@ class Dimension {
     }
     /** Define the canonical base unit (identity transform). */
     base(name, aliases = []) {
-        const unit = this.define(name, (x) => x, (x) => x, aliases);
+        const unit = this.defineLinear(name, { scale: one, offset: zero }, aliases);
         this.baseUnit = unit;
         return unit;
     }
     /**
      * Define a linear unit. `scale` is how many base units make up one of this
-     * unit (e.g. a kilometer is `1000` meters).
+     * unit (e.g. a kilometer is `1000` meters). Pass a {@link Rational} for a
+     * scale a decimal cannot represent exactly.
      */
     unit(name, scale, aliases = []) {
-        return this.define(name, (x) => x * scale, (x) => x / scale, aliases);
+        return this.defineLinear(name, { scale: Rational_1.Rational.from(scale), offset: zero }, aliases);
     }
     /** Define an affine unit (scale plus additive offset, e.g. °C against K). */
     affine(name, { scale, offset }, aliases = []) {
-        return this.define(name, (x) => x * scale + offset, (x) => (x - offset) / scale, aliases);
+        return this.defineLinear(name, { scale: Rational_1.Rational.from(scale), offset: Rational_1.Rational.from(offset) }, aliases);
     }
-    /** Define a unit with an arbitrary, hand-written inverse transform pair. */
+    /**
+     * Define a non-linear unit from an arbitrary, hand-written inverse transform
+     * pair. Reserve this for units that genuinely cannot be expressed as `value *
+     * scale + offset` — e.g. logarithmic scales (decibels, octaves). Linear and
+     * affine units should use {@link unit} / {@link affine} so conversions stay
+     * exact.
+     */
     custom(name, { toBase, fromBase }, aliases = []) {
-        return this.define(name, toBase, fromBase, aliases);
+        return this.define(name, aliases, { toBase, fromBase });
     }
-    /** Convert a value between two units of this dimension, routed through the base. */
+    /** Convert a `number` value between two units of this dimension. */
     convert(value, from, to) {
+        return this.convertRational(Rational_1.Rational.from(value), from, to).toNumber();
+    }
+    /**
+     * Convert an exact {@link Rational} value between two units, routed through
+     * the base. Linear / affine units stay exact end-to-end (the result is never
+     * collapsed to a float here), which is what lets {@link Quantity} chain
+     * conversions without drift. A conversion touching a non-linear `custom` unit
+     * falls back to float math and recaptures the result as a rational.
+     */
+    convertRational(value, from, to) {
         if (!this.units.has(from) || !this.units.has(to)) {
             throw new InvalidConversionError_1.InvalidConversionError(from, to);
         }
         if (from === to) {
             return value;
         }
-        return to.fromBase(from.toBase(value));
+        if (from.linear && to.linear) {
+            // base = from.scale * value + from.offset; result = (base - to.offset) / to.scale
+            const base = from.linear.scale.times(value).plus(from.linear.offset);
+            return base.minus(to.linear.offset).dividedBy(to.linear.scale);
+        }
+        return Rational_1.Rational.from(to.fromBase(from.toBase(value.toNumber())));
     }
     /** Resolve a name or alias to its candidate unit(s) (used by parsing). */
     get(token) {
@@ -67,13 +98,17 @@ class Dimension {
     has(unit) {
         return this.units.has(unit);
     }
-    define(name, toBase, fromBase, aliases) {
+    /** Define a linear / affine unit from its exact rational transform. */
+    defineLinear(name, linear, aliases) {
+        return this.define(name, aliases, { linear });
+    }
+    define(name, aliases, transform) {
         for (const existing of this.units) {
             if (existing.name === name) {
                 throw new Error(`Duplicate unit name "${name}" in dimension "${this.name}"`);
             }
         }
-        const unit = new Unit_1.Unit({ name, dimension: this, toBase, fromBase });
+        const unit = new Unit_1.Unit({ name, dimension: this, ...transform });
         this.units.add(unit);
         this.register(name, unit);
         for (const alias of aliases) {

package/dist/lib/MeasurementSystem.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MeasurementSystem = void 0;
-const scale_1 = require("./scale");
+const scaleOf_1 = require("../utils/scaleOf");
 /**
  * A measurement system (metric, imperial, US customary, …) is a cross-dimension
  * collection of units that share a real-world standard.
@@ -37,7 +37,7 @@ class MeasurementSystem {
      * to the smallest unit when even that rounds below 1).
      */
     express(quantity) {
-        const candidates = this.in(quantity.unit.dimension).sort((a, b) => (0, scale_1.scaleOf)(a) - (0, scale_1.scaleOf)(b));
+        const candidates = this.in(quantity.unit.dimension).sort((a, b) => (0, scaleOf_1.scaleOf)(a) - (0, scaleOf_1.scaleOf)(b));
         if (candidates.length === 0) {
             throw new Error(`Measurement system "${this.name}" has no ` +
                 `"${quantity.unit.dimension.name}" units to express in`);

package/dist/lib/Quantity.d.ts

@@ -1,5 +1,6 @@
 import type { Dimension } from "./Dimension";
 import type { MeasurementSystem } from "./MeasurementSystem";
+import { Rational } from "./Rational";
 import type { Unit } from "./Unit";
 /** Options for {@link Quantity.parse}. */
 export interface ParseOptions {
@@ -8,13 +9,25 @@ export interface ParseOptions {
 }
 /** A magnitude paired with a unit (e.g. `5` `kilometer`). */
 export declare class Quantity {
-    magnitude: number;
-    unit: Unit;
-    constructor(magnitude: number, unit: Unit);
+    readonly unit: Unit;
+    /**
+     * The magnitude as an exact {@link Rational} — the source of truth this
+     * quantity is built on. Conversions and arithmetic operate on it directly, so
+     * a chain like `q.to(a).to(b)` stays exact instead of accumulating the binary
+     * rounding of repeated float round trips. (Exact for linear / affine units; a
+     * conversion through a non-linear `custom` unit recaptures a float as a
+     * rational, so it is best-effort there.)
+     */
+    readonly rational: Rational;
+    constructor(magnitude: number | Rational, unit: Unit);
+    /** The magnitude as a `number`, derived from {@link rational}. */
+    get magnitude(): number;
     /** Return an equivalent quantity expressed in `target`. */
     to(target: Unit): Quantity;
     /** Return this quantity's raw magnitude expressed in `target`. */
     in(target: Unit): number;
+    /** This quantity's exact magnitude expressed in `target`. */
+    private inRational;
     /** Render as `"<magnitude> <unit name>"`, e.g. `"5 kilometer"`. */
     toString(): string;
     /**
@@ -31,9 +44,9 @@ export declare class Quantity {
     /** Subtract another quantity, returned in this quantity's unit. */
     minus(other: Quantity): Quantity;
     /** Scale this quantity by a dimensionless factor. */
-    times(factor: number): Quantity;
+    times(factor: number | Rational): Quantity;
     /** Divide this quantity by a dimensionless divisor. */
-    dividedBy(divisor: number): Quantity;
+    dividedBy(divisor: number | Rational): Quantity;
     /**
      * Divide this quantity by `other` of the same dimension, yielding the
      * dimensionless ratio between them — i.e. how many of `other` fit in this.
@@ -54,14 +67,15 @@ export declare class Quantity {
     /** Alias for {@link minus}. */
     sub(other: Quantity): Quantity;
     /** Alias for {@link times}. */
-    mul(factor: number): Quantity;
+    mul(factor: number | Rational): Quantity;
     /** Alias for {@link dividedBy}. */
-    div(divisor: number): Quantity;
+    div(divisor: number | Rational): Quantity;
     /**
      * Whether this quantity equals `other`, compared in this quantity's unit.
      * Throws {@link InvalidConversionError} if the operands belong to different
-     * dimensions. Comparison is exact, so values that differ only by
-     * floating-point rounding from a conversion may compare unequal.
+     * dimensions. Comparison is exact rational equality, so quantities that are
+     * mathematically equal compare equal even if reaching them involved a
+     * conversion that would have drifted in floating point.
      */
     equals(other: Quantity): boolean;
     /** Whether this quantity does not equal `other`. */
@@ -104,7 +118,7 @@ export declare class Quantity {
      *  - `"5 hr"`       -> `Quantity(5, hour)`
      *  - `"5hr 20min"`  -> `Quantity(320, minute)`
      *
-     * Compound inputs are summed in base units and returned in the *finest*
+     * Compound inputs are summed (exactly) and returned in the *finest*
      * (smallest-scale) unit present, so `"5hr 20min"` collapses to `320 minute`.
      *
      * When a token is a shared alias (e.g. `"ton"` → short ton & long ton), pass