measurable 1.0.0

package/LICENSE

@@ -0,0 +1,7 @@
+ISC License
+
+Copyright 2026 Matt Huggins
+
+Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,241 @@
+# measurable
+
+Convert between units of measurement, with batteries-included common units and
+first-class support for defining your own.
+
+- **No drift** — each unit defines a single transform to its dimension's base
+  unit; reverse conversions are derived, never stored, so they can't fall out of
+  sync.
+- **Free chaining** — any unit converts to any other in the same dimension
+  (e.g. `mile → inch`) without you defining every pair.
+- **Affine units** — temperature scales (°C/°F/K) and anything else needing an
+  offset, not just a scale factor.
+- **Two orthogonal ideas** — a **dimension** decides what _can_ convert; a
+  **measurement system** (metric/imperial/US) is a tag that never gates
+  conversion but powers filtering, formatting, and parse disambiguation.
+
+## Installation
+
+```sh
+npm install measurable
+```
+
+## Entry points
+
+The package is split into three import paths so the core stays lean:
+
+| Import                     | What you get                                                              |
+| -------------------------- | ------------------------------------------------------------------------- |
+| `measurable`             | The building blocks: `Quantity`, `Dimension`, `MeasurementSystem`, `Unit`, errors |
+| `measurable/dimensions`  | Predefined dimensions and their units (`length`, `meter`, `volume`, …)    |
+| `measurable/systems`     | Predefined measurement systems (`metric`, `imperial`, `usCustomary`)      |
+
+## Quick start
+
+```ts
+import { Quantity } from "measurable";
+import { meter, mile, celsius, fahrenheit } from "measurable/dimensions";
+
+// Convert: `.to()` returns a Quantity, `.in()` returns a raw number.
+new Quantity(5, mile).to(meter).magnitude; // 8046.72
+new Quantity(5, mile).in(meter);           // 8046.72
+
+// Affine scales work the same way.
+new Quantity(100, celsius).in(fahrenheit); // 212
+```
+
+## Concepts
+
+- **`Dimension`** — a kind of measurable quantity (length, volume, mass, …). It
+  owns a canonical **base unit** and is where all conversion happens. A unit
+  belongs to exactly one dimension.
+- **`Unit`** — a name plus a transform (`toBase` / `fromBase`) into its
+  dimension's base unit. Created through a dimension's builder methods.
+- **`Quantity`** — a magnitude paired with a unit (e.g. `5 kilometer`).
+- **`MeasurementSystem`** — a cross-dimension tag (metric/imperial/…). A unit can
+  belong to many; membership is optional and never affects whether a conversion
+  is allowed.
+
+## Built-in dimensions
+
+Import any dimension or unit from `measurable/dimensions`:
+
+| Dimension     | Base       | Units (a selection)                                                                 |
+| ------------- | ---------- | ----------------------------------------------------------------------------------- |
+| `length`      | `meter`    | `kilometer`, `centimeter`, `millimeter`, `inch`, `foot`, `yard`, `mile`             |
+| `volume`      | `liter`    | `milliliter`, `us*`/`imperial*` `Gallon`/`Quart`/`Pint`/`Gill`/`FluidOunce`, `cup`, `tablespoon`, `teaspoon` |
+| `mass`        | `kilogram` | `gram`, `milligram`, `tonne`, `pound`, `ounce`, `stone`, `shortTon`, `longTon`      |
+| `time`        | `second`   | `millisecond`, `minute`, `hour`, `day`, `week`                                      |
+| `temperature` | `kelvin`   | `celsius`, `fahrenheit`                                                              |
+| `angle`       | `radian`   | `degree`, `gradian`, `turn`                                                          |
+| `force`       | `newton`   | `kilonewton`, `dyne`, `poundForce`, `kilogramForce`                                  |
+
+## Built-in measurement systems
+
+Import `metric`, `imperial`, or `usCustomary` from `measurable/systems`.
+
+```ts
+import { foot } from "measurable/dimensions";
+import { imperial, usCustomary, metric } from "measurable/systems";
+
+imperial.has(foot);      // true  — a unit can belong to several systems
+usCustomary.has(foot);   // true
+metric.has(foot);        // false
+```
+
+### Listing units in a system
+
+```ts
+import { length } from "measurable/dimensions";
+import { metric } from "measurable/systems";
+
+metric.in(length).map((u) => u.name); // ["meter", "kilometer", "centimeter", "millimeter"]
+```
+
+### Best-fit formatting
+
+`express` re-expresses a quantity in a system's most readable unit (the largest
+unit whose magnitude is still ≥ 1):
+
+```ts
+import { Quantity } from "measurable";
+import { meter } from "measurable/dimensions";
+import { metric, imperial } from "measurable/systems";
+
+metric.express(new Quantity(5000, meter));    // Quantity(5, kilometer)
+imperial.express(new Quantity(5000, meter));  // Quantity(3.107…, mile)
+```
+
+## Parsing strings
+
+`Quantity.parse(input, dimension, options?)` reads a string into a `Quantity`.
+Compound inputs are summed and returned in the finest unit present:
+
+```ts
+import { Quantity } from "measurable";
+import { length, time } from "measurable/dimensions";
+
+Quantity.parse("1km", length);         // Quantity(1, kilometer)
+Quantity.parse("5 hr", time);          // Quantity(5, hour)
+Quantity.parse("5hr 20min", time);     // Quantity(320, minute)
+```
+
+### Ambiguous aliases
+
+Some names mean different things in different systems — a US gallon (3.785 L) is
+not an imperial gallon (4.546 L), and `ton` could be short or long. These are
+distinct units that share an alias, so an unqualified parse throws; pass a
+`prefer`red system to disambiguate:
+
+```ts
+import { Quantity, AmbiguousUnitError } from "measurable";
+import { volume, mass } from "measurable/dimensions";
+import { usCustomary, imperial } from "measurable/systems";
+
+Quantity.parse("1 gallon", volume);                                    // throws AmbiguousUnitError
+Quantity.parse("1 gallon", volume, { prefer: usCustomary }).unit.name; // "usGallon"
+Quantity.parse("1 ton", mass, { prefer: imperial }).unit.name;         // "longTon"
+```
+
+Conversion itself is governed only by the dimension, so cross-system conversions
+always work regardless of tags:
+
+```ts
+import { shortTon, tonne } from "measurable/dimensions";
+
+new Quantity(1, shortTon).in(tonne); // 0.90718474
+```
+
+## Defining your own units
+
+Create a `Dimension` and add units through its builder methods. `scale` is how
+many base units make up one of the unit being defined.
+
+```ts
+import { Dimension, Quantity } from "measurable";
+
+const data = new Dimension("data");
+const byte = data.base("byte", ["B", "bytes"]); // the base unit (identity)
+const kilobyte = data.unit("kilobyte", 1024, ["KB"]);
+const megabyte = data.unit("megabyte", 1024 ** 2, ["MB"]);
+
+new Quantity(2, megabyte).in(kilobyte); // 2048
+```
+
+### Affine units (offset, not just scale)
+
+```ts
+const temperature = new Dimension("temperature");
+const kelvin = temperature.base("kelvin", ["K"]);
+// value_in_base = value * scale + offset
+const celsius = temperature.affine("celsius", { scale: 1, offset: 273.15 }, ["C"]);
+```
+
+### Fully custom transforms
+
+For anything non-linear, provide an explicit inverse pair:
+
+```ts
+const dim = new Dimension("custom");
+dim.base("base");
+dim.custom("squared", {
+  toBase: (x) => x * x,
+  fromBase: (x) => Math.sqrt(x),
+});
+```
+
+### Tagging units into a measurement system
+
+```ts
+import { MeasurementSystem } from "measurable";
+
+const si = new MeasurementSystem("si").add(byte, kilobyte, megabyte);
+si.has(kilobyte); // true
+```
+
+## API reference
+
+### `Dimension`
+
+- `new Dimension(name)`
+- `.base(name, aliases?)` — define the canonical base unit
+- `.unit(name, scale, aliases?)` — linear unit (`scale` base units per unit)
+- `.affine(name, { scale, offset }, aliases?)` — linear with additive offset
+- `.custom(name, { toBase, fromBase }, aliases?)` — arbitrary inverse pair
+- `.convert(value, from, to)` — convert a raw number between two of its units
+- `.get(token)` — units matching a name/alias (`Unit[] | undefined`)
+- `.has(unit)`, `.units`, `.baseUnit`
+
+### `Unit`
+
+A passive handle, normally created via a dimension's builder methods rather than
+`new Unit` directly. Read-only properties:
+
+- `.name` — the unit's canonical name
+- `.dimension` — the `Dimension` it belongs to
+- `.toBase(value)` → `number` — convert a value in this unit to base units
+- `.fromBase(value)` → `number` — convert a value in base units to this unit
+
+### `Quantity`
+
+- `new Quantity(magnitude, unit)`
+- `.to(target)` → `Quantity`
+- `.in(target)` → `number`
+- `Quantity.parse(input, dimension, { prefer? })` → `Quantity`
+
+### `MeasurementSystem`
+
+- `new MeasurementSystem(name)`
+- `.add(...units)`, `.has(unit)`
+- `.in(dimension)` → `Unit[]`
+- `.express(quantity)` → `Quantity`
+
+### Errors
+
+- `InvalidConversionError` — units are from different dimensions
+- `UnknownUnitError` — a parsed token matches no unit
+- `AmbiguousUnitError` — a parsed token matches several units and no `prefer` was given
+
+## License
+
+ISC

package/dist/dimensions/angle.d.ts

@@ -0,0 +1,7 @@
+import { Dimension } from "../lib/Dimension";
+/** Plane angle. Base unit: radian. */
+export declare const angle: Dimension;
+export declare const radian: import("..").Unit;
+export declare const degree: import("..").Unit;
+export declare const gradian: import("..").Unit;
+export declare const turn: import("..").Unit;

package/dist/dimensions/angle.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.turn = exports.gradian = exports.degree = exports.radian = exports.angle = void 0;
+const Dimension_1 = require("../lib/Dimension");
+/** Plane angle. Base unit: radian. */
+exports.angle = new Dimension_1.Dimension("angle");
+exports.radian = exports.angle.base("radian", ["rad", "radians"]);
+exports.degree = exports.angle.unit("degree", Math.PI / 180, ["deg", "°", "degrees"]);
+exports.gradian = exports.angle.unit("gradian", Math.PI / 200, ["grad", "gradians"]);
+exports.turn = exports.angle.unit("turn", 2 * Math.PI, ["turns", "revolution", "revolutions"]);

package/dist/dimensions/force.d.ts

@@ -0,0 +1,8 @@
+import { Dimension } from "../lib/Dimension";
+/** Force. Base unit: newton. */
+export declare const force: Dimension;
+export declare const newton: import("..").Unit;
+export declare const kilonewton: import("..").Unit;
+export declare const dyne: import("..").Unit;
+export declare const poundForce: import("..").Unit;
+export declare const kilogramForce: import("..").Unit;

package/dist/dimensions/force.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kilogramForce = exports.poundForce = exports.dyne = exports.kilonewton = exports.newton = exports.force = void 0;
+const Dimension_1 = require("../lib/Dimension");
+/** Force. Base unit: newton. */
+exports.force = new Dimension_1.Dimension("force");
+exports.newton = exports.force.base("newton", ["N", "newtons"]);
+exports.kilonewton = exports.force.unit("kilonewton", 1000, ["kN", "kilonewtons"]);
+exports.dyne = exports.force.unit("dyne", 0.00001, ["dyn", "dynes"]);
+exports.poundForce = exports.force.unit("poundForce", 4.4482216152605, ["lbf"]);
+exports.kilogramForce = exports.force.unit("kilogramForce", 9.80665, ["kgf"]);

package/dist/dimensions/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./angle";
+export * from "./force";
+export * from "./length";
+export * from "./mass";
+export * from "./temperature";
+export * from "./time";
+export * from "./volume";

package/dist/dimensions/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./angle"), exports);
+__exportStar(require("./force"), exports);
+__exportStar(require("./length"), exports);
+__exportStar(require("./mass"), exports);
+__exportStar(require("./temperature"), exports);
+__exportStar(require("./time"), exports);
+__exportStar(require("./volume"), exports);

package/dist/dimensions/length.d.ts

@@ -0,0 +1,11 @@
+import { Dimension } from "../lib/Dimension";
+/** Length / distance. Base unit: meter. */
+export declare const length: Dimension;
+export declare const meter: import("..").Unit;
+export declare const kilometer: import("..").Unit;
+export declare const centimeter: import("..").Unit;
+export declare const millimeter: import("..").Unit;
+export declare const inch: import("..").Unit;
+export declare const foot: import("..").Unit;
+export declare const yard: import("..").Unit;
+export declare const mile: import("..").Unit;

package/dist/dimensions/length.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mile = exports.yard = exports.foot = exports.inch = exports.millimeter = exports.centimeter = exports.kilometer = exports.meter = exports.length = void 0;
+const Dimension_1 = require("../lib/Dimension");
+/** Length / distance. Base unit: meter. */
+exports.length = new Dimension_1.Dimension("length");
+exports.meter = exports.length.base("meter", ["m", "meters"]);
+exports.kilometer = exports.length.unit("kilometer", 1000, ["km", "kilometers"]);
+exports.centimeter = exports.length.unit("centimeter", 0.01, ["cm", "centimeters"]);
+exports.millimeter = exports.length.unit("millimeter", 0.001, ["mm", "millimeters"]);
+exports.inch = exports.length.unit("inch", 0.0254, ["in", "inches"]);
+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"]);

package/dist/dimensions/mass.d.ts

@@ -0,0 +1,12 @@
+import { Dimension } from "../lib/Dimension";
+/** Mass / weight. Base unit: kilogram. */
+export declare const mass: Dimension;
+export declare const kilogram: import("..").Unit;
+export declare const gram: import("..").Unit;
+export declare const milligram: import("..").Unit;
+export declare const tonne: import("..").Unit;
+export declare const pound: import("..").Unit;
+export declare const ounce: import("..").Unit;
+export declare const stone: import("..").Unit;
+export declare const shortTon: import("..").Unit;
+export declare const longTon: import("..").Unit;

package/dist/dimensions/mass.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.longTon = exports.shortTon = exports.stone = exports.ounce = exports.pound = exports.tonne = exports.milligram = exports.gram = exports.kilogram = exports.mass = void 0;
+const Dimension_1 = require("../lib/Dimension");
+/** Mass / weight. Base unit: kilogram. */
+exports.mass = new Dimension_1.Dimension("mass");
+exports.kilogram = exports.mass.base("kilogram", ["kg", "kilograms"]);
+exports.gram = exports.mass.unit("gram", 0.001, ["g", "grams"]);
+exports.milligram = exports.mass.unit("milligram", 0.000001, ["mg", "milligrams"]);
+exports.tonne = exports.mass.unit("tonne", 1000, ["t", "tonnes"]);
+exports.pound = exports.mass.unit("pound", 0.45359237, ["lb", "lbs", "pounds"]);
+exports.ounce = exports.mass.unit("ounce", 0.028349523125, ["oz", "ounces"]);
+exports.stone = exports.mass.unit("stone", 6.35029318, ["st", "stones"]);
+// Short (US) and long (Imperial) tons share the "ton" alias but differ in size;
+// the metric tonne above is a separate unit again. Parsing disambiguates these.
+exports.shortTon = exports.mass.unit("shortTon", 907.18474, ["ton", "tons"]);
+exports.longTon = exports.mass.unit("longTon", 1016.0469088, ["ton", "tons"]);

package/dist/dimensions/temperature.d.ts

@@ -0,0 +1,9 @@
+import { Dimension } from "../lib/Dimension";
+/**
+ * Temperature. Base unit: kelvin. Uses affine units because Celsius and
+ * Fahrenheit are offset from the base, not just scaled.
+ */
+export declare const temperature: Dimension;
+export declare const kelvin: import("..").Unit;
+export declare const celsius: import("..").Unit;
+export declare const fahrenheit: import("..").Unit;

package/dist/dimensions/temperature.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fahrenheit = exports.celsius = exports.kelvin = exports.temperature = void 0;
+const Dimension_1 = require("../lib/Dimension");
+/**
+ * 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");
+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"]);

package/dist/dimensions/time.d.ts

@@ -0,0 +1,9 @@
+import { Dimension } from "../lib/Dimension";
+/** Time / duration. Base unit: second. */
+export declare const time: Dimension;
+export declare const second: import("..").Unit;
+export declare const millisecond: import("..").Unit;
+export declare const minute: import("..").Unit;
+export declare const hour: import("..").Unit;
+export declare const day: import("..").Unit;
+export declare const week: import("..").Unit;

package/dist/dimensions/time.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.week = exports.day = exports.hour = exports.minute = exports.millisecond = exports.second = exports.time = void 0;
+const Dimension_1 = require("../lib/Dimension");
+/** Time / duration. Base unit: second. */
+exports.time = new Dimension_1.Dimension("time");
+exports.second = exports.time.base("second", ["s", "sec", "secs", "seconds"]);
+exports.millisecond = exports.time.unit("millisecond", 0.001, ["ms", "milliseconds"]);
+exports.minute = exports.time.unit("minute", 60, ["min", "mins", "minutes"]);
+exports.hour = exports.time.unit("hour", 3600, ["h", "hr", "hrs", "hours"]);
+exports.day = exports.time.unit("day", 86400, ["d", "days"]);
+exports.week = exports.time.unit("week", 604800, ["wk", "weeks"]);

package/dist/dimensions/volume.d.ts

@@ -0,0 +1,18 @@
+import { Dimension } from "../lib/Dimension";
+/** Volume / capacity. Base unit: liter. */
+export declare const volume: Dimension;
+export declare const liter: import("..").Unit;
+export declare const milliliter: import("..").Unit;
+export declare const usGallon: import("..").Unit;
+export declare const usQuart: import("..").Unit;
+export declare const usPint: import("..").Unit;
+export declare const usGill: import("..").Unit;
+export declare const usFluidOunce: import("..").Unit;
+export declare const imperialGallon: import("..").Unit;
+export declare const imperialQuart: import("..").Unit;
+export declare const imperialPint: import("..").Unit;
+export declare const imperialGill: import("..").Unit;
+export declare const imperialFluidOunce: import("..").Unit;
+export declare const cup: import("..").Unit;
+export declare const tablespoon: import("..").Unit;
+export declare const teaspoon: import("..").Unit;

package/dist/dimensions/volume.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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.milliliter = exports.liter = exports.volume = void 0;
+const Dimension_1 = require("../lib/Dimension");
+/** Volume / capacity. Base unit: liter. */
+exports.volume = new Dimension_1.Dimension("volume");
+exports.liter = exports.volume.base("liter", ["L", "liters"]);
+exports.milliliter = exports.volume.unit("milliliter", 0.001, ["mL", "milliliters"]);
+// US and Imperial liquid measures share names ("gallon", "pint", …) but differ
+// in size, so each is a distinct unit carrying the shared aliases; parsing
+// disambiguates via a preferred measurement system. Imperial has 160 fluid
+// ounces per gallon, US customary has 128.
+exports.usGallon = exports.volume.unit("usGallon", 3.785411784, ["gal", "gallon", "gallons"]);
+exports.usQuart = exports.volume.unit("usQuart", 0.946352946, ["qt", "quart", "quarts"]);
+exports.usPint = exports.volume.unit("usPint", 0.473176473, ["pt", "pint", "pints"]);
+exports.usGill = exports.volume.unit("usGill", 0.11829411825, ["gill", "gills"]);
+exports.usFluidOunce = exports.volume.unit("usFluidOunce", 0.0295735295625, [
+    "floz",
+    "fluidOunce",
+    "fluidOunces",
+]);
+exports.imperialGallon = exports.volume.unit("imperialGallon", 4.54609, ["gal", "gallon", "gallons"]);
+exports.imperialQuart = exports.volume.unit("imperialQuart", 1.1365225, ["qt", "quart", "quarts"]);
+exports.imperialPint = exports.volume.unit("imperialPint", 0.56826125, ["pt", "pint", "pints"]);
+exports.imperialGill = exports.volume.unit("imperialGill", 0.1420653125, ["gill", "gills"]);
+exports.imperialFluidOunce = exports.volume.unit("imperialFluidOunce", 0.0284130625, [
+    "floz",
+    "fluidOunce",
+    "fluidOunces",
+]);
+// US-only cooking measures (no competing imperial unit, so left unprefixed).
+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"]);

package/dist/errors/AmbiguousUnitError.d.ts

@@ -0,0 +1,4 @@
+import type { Unit } from "../lib/Unit";
+export declare class AmbiguousUnitError extends Error {
+    constructor(token: string, candidates: Unit[]);
+}

package/dist/errors/AmbiguousUnitError.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AmbiguousUnitError = void 0;
+class AmbiguousUnitError extends Error {
+    constructor(token, candidates) {
+        const names = candidates.map((unit) => unit.name).join(", ");
+        super(`Ambiguous unit "${token}": matches ${names}. ` +
+            `Pass a preferred measurement system to disambiguate.`);
+    }
+}
+exports.AmbiguousUnitError = AmbiguousUnitError;

package/dist/errors/InvalidConversionError.d.ts

@@ -0,0 +1,4 @@
+import type { Unit } from "../lib/Unit";
+export declare class InvalidConversionError extends Error {
+    constructor(from: Unit, to: Unit);
+}

package/dist/errors/InvalidConversionError.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidConversionError = void 0;
+class InvalidConversionError extends Error {
+    constructor(from, to) {
+        super(`Invalid conversion: ${from.name} to ${to.name}`);
+    }
+}
+exports.InvalidConversionError = InvalidConversionError;

package/dist/errors/UnknownUnitError.d.ts

@@ -0,0 +1,4 @@
+import type { Dimension } from "../lib/Dimension";
+export declare class UnknownUnitError extends Error {
+    constructor(token: string, dimension: Dimension);
+}

package/dist/errors/UnknownUnitError.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnknownUnitError = void 0;
+class UnknownUnitError extends Error {
+    constructor(token, dimension) {
+        super(`Unknown unit "${token}" in dimension "${dimension.name}"`);
+    }
+}
+exports.UnknownUnitError = UnknownUnitError;

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./errors/AmbiguousUnitError";
+export * from "./errors/InvalidConversionError";
+export * from "./errors/UnknownUnitError";
+export * from "./lib/Dimension";
+export * from "./lib/MeasurementSystem";
+export * from "./lib/Quantity";
+export * from "./lib/Unit";

package/dist/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./errors/AmbiguousUnitError"), exports);
+__exportStar(require("./errors/InvalidConversionError"), exports);
+__exportStar(require("./errors/UnknownUnitError"), exports);
+__exportStar(require("./lib/Dimension"), exports);
+__exportStar(require("./lib/MeasurementSystem"), exports);
+__exportStar(require("./lib/Quantity"), exports);
+__exportStar(require("./lib/Unit"), exports);

package/dist/lib/Dimension.d.ts

@@ -0,0 +1,60 @@
+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;
+    /** Constant added (in base units) after scaling. */
+    offset: number;
+}
+/** A fully custom transform pair for non-linear units. */
+export interface CustomSpec {
+    toBase: (value: number) => number;
+    fromBase: (value: number) => number;
+}
+/**
+ * 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.
+ *
+ * A dimension is distinct from a {@link MeasurementSystem} (metric/imperial/…):
+ * the dimension decides what *can convert*, while a measurement system is a tag
+ * that never participates in conversion.
+ */
+export declare class Dimension {
+    readonly name: string;
+    readonly units: Set<Unit>;
+    /**
+     * Lookup from every name/alias to its candidate units, used by parsing. A
+     * token can map to more than one unit (e.g. "ton" → short ton & long ton);
+     * the caller disambiguates with a preferred measurement system.
+     */
+    private readonly index;
+    /** The canonical unit all others convert through. Set by {@link base}. */
+    baseUnit?: Unit;
+    constructor(name: string);
+    /** Define the canonical base unit (identity transform). */
+    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(name: string, scale: number, 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. */
+    custom(name: string, { toBase, fromBase }: CustomSpec, aliases?: string[]): Unit;
+    /** Convert a value between two units of this dimension, routed through the base. */
+    convert(value: number, from: Unit, to: Unit): number;
+    /** Resolve a name or alias to its candidate unit(s) (used by parsing). */
+    get(token: string): Unit[] | undefined;
+    has(unit: Unit): boolean;
+    private define;
+    /** Append a name/alias → unit mapping; shared aliases accumulate candidates. */
+    private register;
+}

package/dist/lib/Dimension.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dimension = void 0;
+const InvalidConversionError_1 = require("../errors/InvalidConversionError");
+const Unit_1 = require("./Unit");
+/**
+ * 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.
+ *
+ * A dimension is distinct from a {@link MeasurementSystem} (metric/imperial/…):
+ * the dimension decides what *can convert*, while a measurement system is a tag
+ * that never participates in conversion.
+ */
+class Dimension {
+    constructor(name) {
+        this.name = name;
+        this.units = new Set();
+        /**
+         * Lookup from every name/alias to its candidate units, used by parsing. A
+         * token can map to more than one unit (e.g. "ton" → short ton & long ton);
+         * the caller disambiguates with a preferred measurement system.
+         */
+        this.index = new Map();
+    }
+    /** Define the canonical base unit (identity transform). */
+    base(name, aliases = []) {
+        const unit = this.define(name, (x) => x, (x) => x, 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(name, scale, aliases = []) {
+        return this.define(name, (x) => x * scale, (x) => x / scale, 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);
+    }
+    /** Define a unit with an arbitrary, hand-written inverse transform pair. */
+    custom(name, { toBase, fromBase }, aliases = []) {
+        return this.define(name, toBase, fromBase, aliases);
+    }
+    /** Convert a value between two units of this dimension, routed through the base. */
+    convert(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));
+    }
+    /** Resolve a name or alias to its candidate unit(s) (used by parsing). */
+    get(token) {
+        return this.index.get(token);
+    }
+    has(unit) {
+        return this.units.has(unit);
+    }
+    define(name, toBase, fromBase, aliases) {
+        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 });
+        this.units.add(unit);
+        this.register(name, unit);
+        for (const alias of aliases) {
+            this.register(alias, unit);
+        }
+        return unit;
+    }
+    /** Append a name/alias → unit mapping; shared aliases accumulate candidates. */
+    register(token, unit) {
+        const candidates = this.index.get(token);
+        if (candidates) {
+            candidates.push(unit);
+        }
+        else {
+            this.index.set(token, [unit]);
+        }
+    }
+}
+exports.Dimension = Dimension;

package/dist/lib/MeasurementSystem.d.ts

@@ -0,0 +1,29 @@
+import type { Dimension } from "./Dimension";
+import { Quantity } from "./Quantity";
+import type { Unit } from "./Unit";
+/**
+ * A measurement system (metric, imperial, US customary, …) is a cross-dimension
+ * collection of units that share a real-world standard.
+ *
+ * It is purely additive metadata: it never participates in conversion (that is
+ * the job of {@link Dimension}). A unit may belong to several measurement
+ * systems — e.g. `foot` is both imperial and US customary — and membership is
+ * optional, so untagged units still convert normally; they simply won't appear
+ * under any standard. Membership lives here, the single source of truth, rather
+ * than on the {@link Unit}.
+ */
+export declare class MeasurementSystem {
+    readonly name: string;
+    readonly units: Set<Unit>;
+    constructor(name: string);
+    add(...units: Unit[]): this;
+    has(unit: Unit): boolean;
+    /** Units of a given dimension that belong to this measurement system. */
+    in(dimension: Dimension): Unit[];
+    /**
+     * Re-express a quantity in this system's best-fit unit for its dimension:
+     * the largest unit whose absolute magnitude is still at least 1 (falling back
+     * to the smallest unit when even that rounds below 1).
+     */
+    express(quantity: Quantity): Quantity;
+}

package/dist/lib/MeasurementSystem.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MeasurementSystem = void 0;
+const scale_1 = require("./scale");
+/**
+ * A measurement system (metric, imperial, US customary, …) is a cross-dimension
+ * collection of units that share a real-world standard.
+ *
+ * It is purely additive metadata: it never participates in conversion (that is
+ * the job of {@link Dimension}). A unit may belong to several measurement
+ * systems — e.g. `foot` is both imperial and US customary — and membership is
+ * optional, so untagged units still convert normally; they simply won't appear
+ * under any standard. Membership lives here, the single source of truth, rather
+ * than on the {@link Unit}.
+ */
+class MeasurementSystem {
+    constructor(name) {
+        this.name = name;
+        this.units = new Set();
+    }
+    add(...units) {
+        for (const unit of units) {
+            this.units.add(unit);
+        }
+        return this;
+    }
+    has(unit) {
+        return this.units.has(unit);
+    }
+    /** Units of a given dimension that belong to this measurement system. */
+    in(dimension) {
+        return [...this.units].filter((unit) => unit.dimension === dimension);
+    }
+    /**
+     * Re-express a quantity in this system's best-fit unit for its dimension:
+     * the largest unit whose absolute magnitude is still at least 1 (falling back
+     * 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));
+        if (candidates.length === 0) {
+            throw new Error(`Measurement system "${this.name}" has no ` +
+                `"${quantity.unit.dimension.name}" units to express in`);
+        }
+        const base = quantity.unit.toBase(quantity.magnitude);
+        let chosen = candidates[0];
+        for (const unit of candidates) {
+            if (Math.abs(unit.fromBase(base)) >= 1) {
+                chosen = unit;
+            }
+            else {
+                break;
+            }
+        }
+        return quantity.to(chosen);
+    }
+}
+exports.MeasurementSystem = MeasurementSystem;

package/dist/lib/Quantity.d.ts

@@ -0,0 +1,32 @@
+import type { Dimension } from "./Dimension";
+import type { MeasurementSystem } from "./MeasurementSystem";
+import type { Unit } from "./Unit";
+/** Options for {@link Quantity.parse}. */
+export interface ParseOptions {
+    /** Preferred measurement system, used only to break ties on shared aliases. */
+    prefer?: MeasurementSystem;
+}
+/** A magnitude paired with a unit (e.g. `5` `kilometer`). */
+export declare class Quantity {
+    magnitude: number;
+    unit: Unit;
+    constructor(magnitude: number, unit: Unit);
+    /** Return an equivalent quantity expressed in `target`. */
+    to(target: Unit): Quantity;
+    /** Return this quantity's raw magnitude expressed in `target`. */
+    in(target: Unit): number;
+    /**
+     * Parse a string into a `Quantity` using a dimension's known units and aliases.
+     *
+     *  - `"1km"`        -> `Quantity(1, kilometer)`
+     *  - `"5 hr"`       -> `Quantity(5, hour)`
+     *  - `"5hr 20min"`  -> `Quantity(320, minute)`
+     *
+     * Compound inputs are summed in base units 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
+     * `options.prefer` to pick the candidate belonging to that measurement system.
+     */
+    static parse(str: string, dimension: Dimension, options?: ParseOptions): Quantity;
+}

package/dist/lib/Quantity.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Quantity = void 0;
+const AmbiguousUnitError_1 = require("../errors/AmbiguousUnitError");
+const UnknownUnitError_1 = require("../errors/UnknownUnitError");
+const scale_1 = require("./scale");
+/** A magnitude paired with a unit (e.g. `5` `kilometer`). */
+class Quantity {
+    constructor(magnitude, unit) {
+        this.magnitude = magnitude;
+        this.unit = unit;
+    }
+    /** Return an equivalent quantity expressed in `target`. */
+    to(target) {
+        return new Quantity(this.in(target), target);
+    }
+    /** Return this quantity's raw magnitude expressed in `target`. */
+    in(target) {
+        return this.unit.dimension.convert(this.magnitude, this.unit, target);
+    }
+    /**
+     * Parse a string into a `Quantity` using a dimension's known units and aliases.
+     *
+     *  - `"1km"`        -> `Quantity(1, kilometer)`
+     *  - `"5 hr"`       -> `Quantity(5, hour)`
+     *  - `"5hr 20min"`  -> `Quantity(320, minute)`
+     *
+     * Compound inputs are summed in base units 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
+     * `options.prefer` to pick the candidate belonging to that measurement system.
+     */
+    static parse(str, dimension, options = {}) {
+        const pattern = /(-?\d+(?:\.\d+)?)\s*([^\d\s]+)/g;
+        let total = 0; // accumulated in base units
+        let finest;
+        let count = 0;
+        for (let match = pattern.exec(str); match !== null; match = pattern.exec(str)) {
+            const value = Number.parseFloat(match[1]);
+            const unit = resolve(match[2], dimension, options.prefer);
+            total += unit.toBase(value);
+            if (!finest || (0, scale_1.scaleOf)(unit) < (0, scale_1.scaleOf)(finest)) {
+                finest = unit;
+            }
+            count += 1;
+        }
+        if (count === 0 || !finest) {
+            throw new Error(`Could not parse a quantity from "${str}"`);
+        }
+        return new Quantity(finest.fromBase(total), finest);
+    }
+}
+exports.Quantity = Quantity;
+/** Resolve a token to a single unit, disambiguating shared aliases by system. */
+function resolve(token, dimension, prefer) {
+    const candidates = dimension.get(token);
+    if (!candidates || candidates.length === 0) {
+        throw new UnknownUnitError_1.UnknownUnitError(token, dimension);
+    }
+    if (candidates.length === 1) {
+        return candidates[0];
+    }
+    if (prefer) {
+        const matches = candidates.filter((unit) => prefer.has(unit));
+        if (matches.length === 1) {
+            return matches[0];
+        }
+    }
+    throw new AmbiguousUnitError_1.AmbiguousUnitError(token, candidates);
+}

package/dist/lib/Unit.d.ts

@@ -0,0 +1,35 @@
+import type { Dimension } from "./Dimension";
+interface UnitOptions {
+    name: string;
+    dimension: Dimension;
+    toBase: (value: number) => number;
+    fromBase: (value: number) => number;
+}
+/**
+ * A single unit of measurement (e.g. "meter", "celsius").
+ *
+ * A `Unit` is a passive handle: it knows its name, its home {@link Dimension},
+ * and how to transform a value to and from that dimension's canonical base
+ * unit. It does NOT know about other units or store pairwise conversions — all
+ * conversion math lives in {@link Dimension}, derived from these two transforms.
+ * Because the reverse direction (`fromBase`) is the mathematical inverse of the
+ * forward direction (`toBase`), the two can never fall out of sync.
+ *
+ * A unit belongs to exactly one dimension, but may belong to many
+ * {@link MeasurementSystem}s (metric/imperial/…); that membership lives on the
+ * measurement systems, not here, so a `Unit` stays a lean descriptor.
+ *
+ * Names and aliases live solely in the dimension's lookup index; they are
+ * declared once when the unit is defined.
+ *
+ * Units are normally created through a {@link Dimension}'s builder methods
+ * (`base`, `unit`, `affine`, `custom`) rather than constructed directly.
+ */
+export declare class Unit {
+    readonly name: string;
+    readonly dimension: Dimension;
+    readonly toBase: (value: number) => number;
+    readonly fromBase: (value: number) => number;
+    constructor({ name, dimension, toBase, fromBase }: UnitOptions);
+}
+export {};

package/dist/lib/Unit.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Unit = void 0;
+/**
+ * A single unit of measurement (e.g. "meter", "celsius").
+ *
+ * A `Unit` is a passive handle: it knows its name, its home {@link Dimension},
+ * and how to transform a value to and from that dimension's canonical base
+ * unit. It does NOT know about other units or store pairwise conversions — all
+ * conversion math lives in {@link Dimension}, derived from these two transforms.
+ * Because the reverse direction (`fromBase`) is the mathematical inverse of the
+ * forward direction (`toBase`), the two can never fall out of sync.
+ *
+ * A unit belongs to exactly one dimension, but may belong to many
+ * {@link MeasurementSystem}s (metric/imperial/…); that membership lives on the
+ * measurement systems, not here, so a `Unit` stays a lean descriptor.
+ *
+ * Names and aliases live solely in the dimension's lookup index; they are
+ * declared once when the unit is defined.
+ *
+ * Units are normally created through a {@link Dimension}'s builder methods
+ * (`base`, `unit`, `affine`, `custom`) rather than constructed directly.
+ */
+class Unit {
+    constructor({ name, dimension, toBase, fromBase }) {
+        this.name = name;
+        this.dimension = dimension;
+        this.toBase = toBase;
+        this.fromBase = fromBase;
+    }
+}
+exports.Unit = Unit;

package/dist/lib/scale.d.ts

@@ -0,0 +1,3 @@
+import type { Unit } from "./Unit";
+/** Pure linear scale of a unit relative to base, ignoring any affine offset. */
+export declare const scaleOf: (unit: Unit) => number;

package/dist/lib/scale.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scaleOf = void 0;
+/** Pure linear scale of a unit relative to base, ignoring any affine offset. */
+const scaleOf = (unit) => unit.toBase(1) - unit.toBase(0);
+exports.scaleOf = scaleOf;

package/dist/systems/imperial.d.ts

@@ -0,0 +1,3 @@
+import { MeasurementSystem } from "../lib/MeasurementSystem";
+/** The British imperial standard. */
+export declare const imperial: MeasurementSystem;

package/dist/systems/imperial.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.imperial = void 0;
+const length_1 = require("../dimensions/length");
+const mass_1 = require("../dimensions/mass");
+const temperature_1 = require("../dimensions/temperature");
+const volume_1 = require("../dimensions/volume");
+const MeasurementSystem_1 = require("../lib/MeasurementSystem");
+/** The British imperial standard. */
+exports.imperial = new MeasurementSystem_1.MeasurementSystem("imperial").add(
+// length
+length_1.inch, length_1.foot, length_1.yard, length_1.mile, 
+// mass
+mass_1.pound, mass_1.ounce, mass_1.stone, mass_1.longTon, 
+// volume
+volume_1.imperialGallon, volume_1.imperialQuart, volume_1.imperialPint, volume_1.imperialGill, volume_1.imperialFluidOunce, 
+// temperature
+temperature_1.fahrenheit);

package/dist/systems/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./imperial";
+export * from "./metric";
+export * from "./usCustomary";

package/dist/systems/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./imperial"), exports);
+__exportStar(require("./metric"), exports);
+__exportStar(require("./usCustomary"), exports);

package/dist/systems/metric.d.ts

@@ -0,0 +1,3 @@
+import { MeasurementSystem } from "../lib/MeasurementSystem";
+/** The metric / SI standard. */
+export declare const metric: MeasurementSystem;

package/dist/systems/metric.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.metric = void 0;
+const length_1 = require("../dimensions/length");
+const mass_1 = require("../dimensions/mass");
+const temperature_1 = require("../dimensions/temperature");
+const volume_1 = require("../dimensions/volume");
+const MeasurementSystem_1 = require("../lib/MeasurementSystem");
+/** The metric / SI standard. */
+exports.metric = new MeasurementSystem_1.MeasurementSystem("metric").add(
+// length
+length_1.meter, length_1.kilometer, length_1.centimeter, length_1.millimeter, 
+// mass
+mass_1.kilogram, mass_1.gram, mass_1.milligram, mass_1.tonne, 
+// volume
+volume_1.liter, volume_1.milliliter, 
+// temperature
+temperature_1.kelvin, temperature_1.celsius);

package/dist/systems/usCustomary.d.ts

@@ -0,0 +1,3 @@
+import { MeasurementSystem } from "../lib/MeasurementSystem";
+/** The US customary standard. Shares foot/pound/ounce with imperial. */
+export declare const usCustomary: MeasurementSystem;

package/dist/systems/usCustomary.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usCustomary = void 0;
+const length_1 = require("../dimensions/length");
+const mass_1 = require("../dimensions/mass");
+const temperature_1 = require("../dimensions/temperature");
+const volume_1 = require("../dimensions/volume");
+const MeasurementSystem_1 = require("../lib/MeasurementSystem");
+/** The US customary standard. Shares foot/pound/ounce with imperial. */
+exports.usCustomary = new MeasurementSystem_1.MeasurementSystem("usCustomary").add(
+// length
+length_1.inch, length_1.foot, length_1.yard, length_1.mile, 
+// mass
+mass_1.pound, mass_1.ounce, mass_1.shortTon, 
+// volume
+volume_1.usGallon, volume_1.usQuart, volume_1.usPint, volume_1.usGill, volume_1.usFluidOunce, volume_1.cup, volume_1.tablespoon, volume_1.teaspoon, 
+// temperature
+temperature_1.fahrenheit);

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "measurable",
+  "version": "1.0.0",
+  "description": "Convert between units of measurement with custom and built-in systems",
+  "keywords": [
+    "conversion",
+    "convert",
+    "magnitude",
+    "measure",
+    "measurement",
+    "measurements",
+    "quantities",
+    "quantity",
+    "unit",
+    "units"
+  ],
+  "author": "Matt Huggins <matt.huggins@gmail.com>",
+  "license": "ISC",
+  "repository": "https://github.com/mhuggins/measurable",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./dimensions": {
+      "types": "./dist/dimensions/index.d.ts",
+      "default": "./dist/dimensions/index.js"
+    },
+    "./systems": {
+      "types": "./dist/systems/index.d.ts",
+      "default": "./dist/systems/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@biomejs/biome": "^2.5.0",
+    "typescript": "^6.0.3",
+    "vite": "^8.0.16",
+    "vitest": "^4.1.9"
+  },
+  "scripts": {
+    "prebuild": "pnpm run lint && pnpm run format && pnpm run typecheck && pnpm run test",
+    "build": "tsc",
+    "lint": "biome check .",
+    "format": "biome format .",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}