@thi.ng/units 0.1.1 → 0.2.0

package/unit.d.ts

@@ -1,3 +1,4 @@
+import type { IDeref } from "@thi.ng/api";
 import { Dimensions, MaybeUnit, NamedUnit, Prefix, Unit } from "./api.js";
 /**
  * Cache/registry for all units defined via {@link defUnit}.
@@ -68,31 +69,99 @@ export declare const asUnit: (id: string) => Unit;
  * @param coherent
  */
 export declare const prefix: (id: Prefix, unit: MaybeUnit, coherent?: boolean) => Unit;
+type QUnit<T extends number | number[]> = T extends number ? Unit : Unit[];
 /**
- * Derives a new unit as the product of the given units. If `coherent` is true
- * (default: false), the new unit itself is considered coherent and can be
- * prefixed later.
+ * Wrapper for scalar or vector quantities. See {@link quantity}.
+ */
+export declare class Quantity<T extends number | number[]> implements IDeref<T> {
+    readonly value: QUnit<T>;
+    constructor(value: QUnit<T>);
+    deref(): T;
+}
+/**
+ * Creates a new {@link Quantity}, i.e. a certain finite amount of a given unit.
+ * `value` can be a number or vector.
+ *
+ * @remarks
+ * The quantities can then be used for calculations & conversions using the
+ * polymorphic functions: {@link div}, {@link mul}, {@link reciprocal} and
+ * {@link convert}.
+ *
+ * The {@link Quantity} class also implements the standard [`IDeref`]()
+ * interface to obtain unwrapped amount (though only should be used for
+ * dimensionless quantities). Use {@link convert} otherwise!
+ *
+ * @example
+ * ```ts
+ * const speedOfLight = quantity(299792458, "m/s");
+ *
+ * // compute wavelength of a WiFi signal in millimeters
+ * convert(div(speedOfLight, quantity(2.4,"GHz")), "mm");
+ * // 124.9135
+ *
+ * // DIN A4 paper size
+ * const A4 = quantity([210, 297], "mm");
+ *
+ * // convert paper size to inches
+ * convert(A4, "in");
+ * // [ 8.2677, 11.6929 ]
+ *
+ * // or calculate pixel dimensions @ 300 dpi
+ * // the result of the product is dimensionless so we use NONE as target unit
+ * convert(mul(A4, quantity(300, "dpi")), NONE)
+ * // [ 2480.314960629921, 3507.8740157480315 ]
+ *
+ * // alternatively dimensionless units can be deref'd directly
+ * mul(A4, quantity(300, "dpi")).deref()
+ * // [ 2480.314960629921, 3507.8740157480315 ]
+ * ```
+ *
+ * @param value
+ * @param unit
+ */
+export declare const quantity: <T extends number | number[]>(value: T, unit: MaybeUnit) => Quantity<T>;
+/**
+ * Polymorphic function. Derives a new quantity or unit as the product of the
+ * given quantities/units.
+ *
+ * @remarks
+ * If given units and if `coherent` is true (default: false), the new unit
+ * itself is considered coherent and can be prefixed later.
  *
  * @param a
  * @param b
  * @param coherent
  */
-export declare const mul: (a: MaybeUnit, b: MaybeUnit | number, coherent?: boolean) => Unit;
+export declare function mul(a: Quantity<number>, b: Quantity<number>): Quantity<number>;
+export declare function mul(a: Quantity<number>, b: Quantity<number[]>): Quantity<number[]>;
+export declare function mul(a: Quantity<number[]>, b: Quantity<number>): Quantity<number[]>;
+export declare function mul(a: Quantity<number[]>, b: Quantity<number[]>): Quantity<number[]>;
+export declare function mul(a: MaybeUnit, b: MaybeUnit | number, coherent?: boolean): Unit;
 /**
- * Derives a new unit via the division of the given units. If `coherent` is true
- * (default: false), the new unit itself is considered coherent and can be
- * prefixed later.
+ * Polymorphic function. Derives a new quantity or unit via the division of the
+ * given quantities/units.
+ *
+ * @remarks
+ * If given units and if `coherent` is true (default: false), the new unit
+ * itself is considered coherent and can be prefixed later.
  *
  * @param a
  * @param b
  * @param coherent
  */
-export declare const div: (a: MaybeUnit, b: MaybeUnit | number, coherent?: boolean) => Unit;
+export declare function div(a: Quantity<number>, b: Quantity<number>): Quantity<number>;
+export declare function div(a: Quantity<number>, b: Quantity<number[]>): Quantity<number[]>;
+export declare function div(a: Quantity<number[]>, b: Quantity<number>): Quantity<number[]>;
+export declare function div(a: Quantity<number[]>, b: Quantity<number[]>): Quantity<number[]>;
+export declare function div(a: MaybeUnit, b: MaybeUnit | number, coherent?: boolean): Unit;
 /**
- * Creates the reciprocal version of given unit (i.e. all SI dimensions will
- * flip sign) and the scale factor of the new unit will be `1/scale`. If
- * `coherent` is true (default: false), the new unit itself is considered
- * coherent and can be prefixed later.
+ * Polymorphic function. Creates the reciprocal version of given quantity or
+ * unit (i.e. all SI dimensions will flip sign) and the scale factor of the new
+ * unit will be `1/scale`.
+ *
+ * @remarks
+ * If given a unit and if `coherent` is true (default: false), the new unit
+ * itself is considered coherent and can be prefixed later.
  *
  * @example
  * ```ts
@@ -102,7 +171,9 @@ export declare const div: (a: MaybeUnit, b: MaybeUnit | number, coherent?: boole
  * @param u
  * @param coherent
  */
-export declare const reciprocal: (u: MaybeUnit, coherent?: boolean) => Unit;
+export declare function reciprocal(u: Quantity<number>): Quantity<number>;
+export declare function reciprocal(u: Quantity<number[]>): Quantity<number[]>;
+export declare function reciprocal(u: MaybeUnit, coherent?: boolean): Unit;
 /**
  * Raises given unit to power `k`. If `coherent` is true (default: false), the
  * new unit itself is considered coherent and can be prefixed later.
@@ -121,8 +192,11 @@ export declare const reciprocal: (u: MaybeUnit, coherent?: boolean) => Unit;
  */
 export declare const pow: (u: MaybeUnit, k: number, coherent?: boolean) => Unit;
 /**
- * Attempts to convert `x` from `src` unit into `dest` unit. Throws an error if
- * units are incompatible.
+ * Polymorphic function. If given a {@link Quantity}, attempts to convert it to
+ * given `dest` unit and returns result as raw/unwrapped value (or vector).
+ * Otherwise, attempts to convert `x` amount from `src` unit into `dest` unit
+ * and returns result. In all cases an error is thrown if units are
+ * incompatible.
  *
  * @remarks
  * Units can only be converted if their SI dimensions are compatible. See
@@ -132,20 +206,21 @@ export declare const pow: (u: MaybeUnit, k: number, coherent?: boolean) => Unit;
  * @param src
  * @param dest
  */
-export declare const convert: (x: number, src: MaybeUnit, dest: MaybeUnit) => number;
+export declare function convert<T extends number | number[]>(x: Quantity<T>, dest: MaybeUnit): T;
+export declare function convert(x: number, src: MaybeUnit, dest: MaybeUnit): number;
 /**
- * Returns true if `src` unit is convertible to `dest`.
+ * Returns true if `src` quantity or unit is convertible to `dest` unit.
  *
  * @param src
  * @param dest
  */
-export declare const isConvertible: (src: MaybeUnit, dest: MaybeUnit) => boolean;
+export declare const isConvertible: (src: Quantity<any> | MaybeUnit, dest: MaybeUnit) => boolean;
 /**
- * Returns true, if `u` is a dimensionless unit.
+ * Returns true, if `u` is a dimensionless quantity or unit.
  *
  * @param u
  */
-export declare const isDimensionless: (u: MaybeUnit) => boolean;
+export declare const isDimensionless: (u: Quantity<any> | MaybeUnit) => boolean;
 /**
  * Returns true if the two given units are reciprocal to each other (and
  * therefore can be used for conversion).
@@ -154,5 +229,12 @@ export declare const isDimensionless: (u: MaybeUnit) => boolean;
  * @param b
  */
 export declare const isReciprocal: (a: MaybeUnit, b: MaybeUnit) => boolean;
-export declare const formatSI: (u: MaybeUnit) => string;
+/**
+ * Polymorphic function. Returns formatted version of given quantity's or unit's
+ * SI dimension vector.
+ *
+ * @param u
+ */
+export declare const formatSI: (u: Quantity<any> | MaybeUnit) => string;
+export {};
 //# sourceMappingURL=unit.d.ts.map

package/unit.js

@@ -1,9 +1,10 @@
+import { isArray } from "@thi.ng/checks";
 import { isNumber } from "@thi.ng/checks/is-number";
 import { isString } from "@thi.ng/checks/is-string";
 import { equivArrayLike } from "@thi.ng/equiv";
 import { assert } from "@thi.ng/errors/assert";
 import { illegalArgs } from "@thi.ng/errors/illegal-arguments";
-import { PREFIXES, } from "./api.js";
+import { NONE, PREFIXES, } from "./api.js";
 /**
  * Cache/registry for all units defined via {@link defUnit}.
  */
@@ -39,7 +40,7 @@ export const coherent = (dim) => unit(dim, 1, 0, true);
  * @param offset
  * @param coherent
  */
-export const dimensionless = (scale, offset = 0, coherent = false) => unit([0, 0, 0, 0, 0, 0, 0], scale, offset, coherent);
+export const dimensionless = (scale, offset = 0, coherent = false) => unit(NONE.dim, scale, offset, coherent);
 /**
  * Takes a unit symbol, full unit name and pre-defined {@link Unit} impl and
  * registers it in the {@link UNITS} cache for further lookups by symbol name.
@@ -71,7 +72,9 @@ export const asUnit = (id) => {
         if (unit) {
             return PREFIXES[pre] !== undefined
                 ? prefix(pre, unit)
-                : unit;
+                : !pre
+                    ? unit
+                    : illegalArgs(`unknown unit: ${id}`);
         }
     }
     for (let u in UNITS) {
@@ -103,54 +106,88 @@ export const prefix = (id, unit, coherent = false) => {
         : illegalArgs("unit isn't coherent");
 };
 /**
- * Derives a new unit as the product of the given units. If `coherent` is true
- * (default: false), the new unit itself is considered coherent and can be
- * prefixed later.
+ * Wrapper for scalar or vector quantities. See {@link quantity}.
+ */
+export class Quantity {
+    constructor(value) {
+        this.value = value;
+    }
+    deref() {
+        return ((isArray(this.value)
+            ? this.value.map((x) => x.scale)
+            : this.value.scale));
+    }
+}
+/**
+ * Creates a new {@link Quantity}, i.e. a certain finite amount of a given unit.
+ * `value` can be a number or vector.
  *
- * @param a
- * @param b
- * @param coherent
+ * @remarks
+ * The quantities can then be used for calculations & conversions using the
+ * polymorphic functions: {@link div}, {@link mul}, {@link reciprocal} and
+ * {@link convert}.
+ *
+ * The {@link Quantity} class also implements the standard [`IDeref`]()
+ * interface to obtain unwrapped amount (though only should be used for
+ * dimensionless quantities). Use {@link convert} otherwise!
+ *
+ * @example
+ * ```ts
+ * const speedOfLight = quantity(299792458, "m/s");
+ *
+ * // compute wavelength of a WiFi signal in millimeters
+ * convert(div(speedOfLight, quantity(2.4,"GHz")), "mm");
+ * // 124.9135
+ *
+ * // DIN A4 paper size
+ * const A4 = quantity([210, 297], "mm");
+ *
+ * // convert paper size to inches
+ * convert(A4, "in");
+ * // [ 8.2677, 11.6929 ]
+ *
+ * // or calculate pixel dimensions @ 300 dpi
+ * // the result of the product is dimensionless so we use NONE as target unit
+ * convert(mul(A4, quantity(300, "dpi")), NONE)
+ * // [ 2480.314960629921, 3507.8740157480315 ]
+ *
+ * // alternatively dimensionless units can be deref'd directly
+ * mul(A4, quantity(300, "dpi")).deref()
+ * // [ 2480.314960629921, 3507.8740157480315 ]
+ * ```
+ *
+ * @param value
+ * @param unit
  */
-export const mul = (a, b, coherent = false) => {
+export const quantity = (value, unit) => new Quantity(((isNumber(value)
+    ? mul(unit, value)
+    : value.map((x) => mul(unit, x)))));
+export function mul(a, b, coherent = false) {
+    if (a instanceof Quantity)
+        return __combineQ(mul, a, b);
     const $a = __ensureUnit(a);
-    if (isNumber(b)) {
+    if (isNumber(b))
         return unit($a.dim, $a.scale * b, $a.offset, coherent);
-    }
     const $b = __ensureUnit(b);
     return unit($a.dim.map((x, i) => x + $b.dim[i]), $a.scale * $b.scale, 0, coherent);
-};
-/**
- * Derives a new unit via the division of the given units. If `coherent` is true
- * (default: false), the new unit itself is considered coherent and can be
- * prefixed later.
- *
- * @param a
- * @param b
- * @param coherent
- */
-export const div = (a, b, coherent = false) => {
+}
+export function div(a, b, coherent = false) {
+    if (a instanceof Quantity)
+        return __combineQ(div, a, b);
     const $a = __ensureUnit(a);
     if (isNumber(b)) {
         return unit($a.dim, $a.scale / b, $a.offset, coherent);
     }
     const $b = __ensureUnit(b);
     return unit($a.dim.map((x, i) => x - $b.dim[i]), $a.scale / $b.scale, 0, coherent);
-};
-/**
- * Creates the reciprocal version of given unit (i.e. all SI dimensions will
- * flip sign) and the scale factor of the new unit will be `1/scale`. If
- * `coherent` is true (default: false), the new unit itself is considered
- * coherent and can be prefixed later.
- *
- * @example
- * ```ts
- * const HZ = reciprocal(S, true);
- * ```
- *
- * @param u
- * @param coherent
- */
-export const reciprocal = (u, coherent = false) => div(dimensionless(1), u, coherent);
+}
+export function reciprocal(u, coherent = false) {
+    return u instanceof Quantity
+        ? new Quantity(isArray(u.value)
+            ? u.value.map((x) => div(NONE, x))
+            : div(NONE, u.value))
+        : div(NONE, u, coherent);
+}
 /**
  * Raises given unit to power `k`. If `coherent` is true (default: false), the
  * new unit itself is considered coherent and can be prefixed later.
@@ -171,44 +208,41 @@ export const pow = (u, k, coherent = false) => {
     const $u = __ensureUnit(u);
     return unit($u.dim.map((x) => x * k), $u.scale ** k, 0, coherent);
 };
-/**
- * Attempts to convert `x` from `src` unit into `dest` unit. Throws an error if
- * units are incompatible.
- *
- * @remarks
- * Units can only be converted if their SI dimensions are compatible. See
- * {@link isConvertible}.
- *
- * @param x
- * @param src
- * @param dest
- */
-export const convert = (x, src, dest) => {
-    const $src = __ensureUnit(src);
-    const $dest = __ensureUnit(dest);
+export function convert(x, a, b) {
+    const $src = __ensureUnit(a);
+    if (x instanceof Quantity) {
+        return isArray(x.value)
+            ? x.value.map((y) => convert(1, y, $src))
+            : convert(1, x.value, $src);
+    }
+    const $dest = __ensureUnit(b);
     const xnorm = x * $src.scale + $src.offset;
     if (isReciprocal($src, $dest))
         return (1 / xnorm - $dest.offset) / $dest.scale;
     assert(equivArrayLike($src.dim, $dest.dim), "incompatible dimensions");
     return (xnorm - $dest.offset) / $dest.scale;
-};
+}
 /**
- * Returns true if `src` unit is convertible to `dest`.
+ * Returns true if `src` quantity or unit is convertible to `dest` unit.
  *
  * @param src
  * @param dest
  */
 export const isConvertible = (src, dest) => {
+    if (src instanceof Quantity)
+        return isConvertible(__qunit(src), dest);
     const $src = __ensureUnit(src);
     const $dest = __ensureUnit(dest);
     return isReciprocal($src, $dest) || equivArrayLike($src.dim, $dest.dim);
 };
 /**
- * Returns true, if `u` is a dimensionless unit.
+ * Returns true, if `u` is a dimensionless quantity or unit.
  *
  * @param u
  */
-export const isDimensionless = (u) => __ensureUnit(u).dim.every((x) => x === 0);
+export const isDimensionless = (u) => u instanceof Quantity
+    ? isDimensionless(__qunit(u))
+    : __ensureUnit(u).dim.every((x) => x === 0);
 /**
  * Returns true if the two given units are reciprocal to each other (and
  * therefore can be used for conversion).
@@ -231,7 +265,15 @@ export const isReciprocal = (a, b) => {
     }
     return ok;
 };
+/**
+ * Polymorphic function. Returns formatted version of given quantity's or unit's
+ * SI dimension vector.
+ *
+ * @param u
+ */
 export const formatSI = (u) => {
+    if (u instanceof Quantity)
+        return formatSI(__qunit(u));
     const { dim } = __ensureUnit(u);
     const SI = ["kg", "m", "s", "A", "K", "mol", "cd"];
     const acc = [];
@@ -250,3 +292,16 @@ const __oneHot = (x) => {
     dims[x] = 1;
     return dims;
 };
+const __qunit = (q) => (isArray(q.value) ? q.value[0] : q.value);
+const __combineQ = (op, a, b) => {
+    const $b = b;
+    const vecA = isArray(a.value);
+    const vecB = isArray($b.value);
+    return new Quantity(vecA
+        ? vecB
+            ? a.value.map((x, i) => op(x, $b.value[i]))
+            : a.value.map((x) => op(x, $b.value))
+        : vecB
+            ? $b.value.map((x) => op(a.value, x))
+            : op(a.value, $b.value));
+};

package/units/accel.d.ts

@@ -0,0 +1,5 @@
+export declare const m_s2: import("../api.js").NamedUnit;
+export declare const ft_s2: import("../api.js").NamedUnit;
+export declare const rad_s2: import("../api.js").NamedUnit;
+export declare const g0: import("../api.js").NamedUnit;
+//# sourceMappingURL=accel.d.ts.map

package/{accel.js → units/accel.js}

@@ -1,7 +1,7 @@
 import { rad } from "./angle.js";
 import { ft, m } from "./length.js";
 import { s } from "./time.js";
-import { defUnit, div, mul, pow } from "./unit.js";
+import { defUnit, div, mul, pow } from "../unit.js";
 const s2 = pow(s, 2);
 export const m_s2 = defUnit("m/s2", "meter per second squared", div(m, s2));
 export const ft_s2 = defUnit("ft/s2", "foot per second squared", div(ft, s2));

package/units/angle.d.ts

@@ -0,0 +1,8 @@
+export declare const rad: import("../api.js").NamedUnit;
+export declare const deg: import("../api.js").NamedUnit;
+export declare const gon: import("../api.js").NamedUnit;
+export declare const turn: import("../api.js").NamedUnit;
+export declare const arcmin: import("../api.js").NamedUnit;
+export declare const arcsec: import("../api.js").NamedUnit;
+export declare const sr: import("../api.js").NamedUnit;
+//# sourceMappingURL=angle.d.ts.map

package/{angle.js → units/angle.js}

@@ -1,4 +1,4 @@
-import { defUnit, dimensionless, mul } from "./unit.js";
+import { defUnit, dimensionless, mul } from "../unit.js";
 const PI = Math.PI;
 export const rad = defUnit("rad", "radian", dimensionless(1, 0, true));
 export const deg = defUnit("deg", "degree", mul(rad, PI / 180));

package/units/area.d.ts

@@ -0,0 +1,10 @@
+export declare const m2: import("../api.js").NamedUnit;
+export declare const mm2: import("../api.js").NamedUnit;
+export declare const cm2: import("../api.js").NamedUnit;
+export declare const km2: import("../api.js").NamedUnit;
+export declare const ha: import("../api.js").NamedUnit;
+export declare const ac: import("../api.js").NamedUnit;
+export declare const sqin: import("../api.js").NamedUnit;
+export declare const sqft: import("../api.js").NamedUnit;
+export declare const sqmi: import("../api.js").NamedUnit;
+//# sourceMappingURL=area.d.ts.map

package/{area.js → units/area.js}

@@ -1,5 +1,5 @@
 import { cm, ft, inch, km, m, mi, mm } from "./length.js";
-import { defUnit, mul, pow } from "./unit.js";
+import { defUnit, mul, pow } from "../unit.js";
 export const m2 = defUnit("m2", "square meter", pow(m, 2));
 export const mm2 = defUnit("mm2", "square millimeter", pow(mm, 2));
 export const cm2 = defUnit("cm2", "square centimeter", pow(cm, 2));

package/units/data.d.ts

@@ -0,0 +1,25 @@
+export declare const bit: import("../api.js").NamedUnit;
+export declare const kbit: import("../api.js").NamedUnit;
+export declare const Mbit: import("../api.js").NamedUnit;
+export declare const Gbit: import("../api.js").NamedUnit;
+export declare const Tbit: import("../api.js").NamedUnit;
+export declare const B: import("../api.js").NamedUnit;
+export declare const kB: import("../api.js").NamedUnit;
+export declare const MB: import("../api.js").NamedUnit;
+export declare const GB: import("../api.js").NamedUnit;
+export declare const TB: import("../api.js").NamedUnit;
+export declare const PB: import("../api.js").NamedUnit;
+export declare const EB: import("../api.js").NamedUnit;
+export declare const Kibit: import("../api.js").NamedUnit;
+export declare const Mibit: import("../api.js").NamedUnit;
+export declare const Gibit: import("../api.js").NamedUnit;
+export declare const Tibit: import("../api.js").NamedUnit;
+export declare const Pibit: import("../api.js").NamedUnit;
+export declare const Eibit: import("../api.js").NamedUnit;
+export declare const KiB: import("../api.js").NamedUnit;
+export declare const MiB: import("../api.js").NamedUnit;
+export declare const GiB: import("../api.js").NamedUnit;
+export declare const TiB: import("../api.js").NamedUnit;
+export declare const PiB: import("../api.js").NamedUnit;
+export declare const EiB: import("../api.js").NamedUnit;
+//# sourceMappingURL=data.d.ts.map

package/{data.js → units/data.js}

@@ -1,4 +1,4 @@
-import { defUnit, dimensionless, mul, prefix } from "./unit.js";
+import { defUnit, dimensionless, mul, prefix } from "../unit.js";
 export const bit = defUnit("bit", "bit", dimensionless(1, 0, true));
 export const kbit = defUnit("kbit", "kilobit", prefix("k", bit));
 export const Mbit = defUnit("Mbit", "megabit", prefix("M", bit));

package/units/density.d.ts

@@ -0,0 +1,3 @@
+export declare const kg_m3: import("../api.js").NamedUnit;
+export declare const dpi: import("../api.js").NamedUnit;
+//# sourceMappingURL=density.d.ts.map

package/units/density.js

@@ -0,0 +1,6 @@
+import { inch } from "./length.js";
+import { kg } from "./mass.js";
+import { defUnit, div, reciprocal } from "../unit.js";
+import { m3 } from "./volume.js";
+export const kg_m3 = defUnit("kg/m3", "kilogram per cubic meter", div(kg, m3));
+export const dpi = defUnit("dpi", "dots per inch", reciprocal(inch));

package/units/electric.d.ts

@@ -0,0 +1,24 @@
+export declare const A: import("../api.js").NamedUnit;
+export declare const mA: import("../api.js").NamedUnit;
+export declare const mAh: import("../api.js").NamedUnit;
+export declare const C: import("../api.js").NamedUnit;
+export declare const V: import("../api.js").NamedUnit;
+export declare const mV: import("../api.js").NamedUnit;
+export declare const kV: import("../api.js").NamedUnit;
+export declare const MV: import("../api.js").NamedUnit;
+export declare const F: import("../api.js").NamedUnit;
+export declare const pF: import("../api.js").NamedUnit;
+export declare const µF: import("../api.js").NamedUnit;
+export declare const Ω: import("../api.js").NamedUnit;
+export declare const kΩ: import("../api.js").NamedUnit;
+export declare const MΩ: import("../api.js").NamedUnit;
+export declare const GΩ: import("../api.js").NamedUnit;
+export declare const ohm: import("../api.js").NamedUnit;
+export declare const kohm: import("../api.js").NamedUnit;
+export declare const Mohm: import("../api.js").NamedUnit;
+export declare const Gohm: import("../api.js").NamedUnit;
+export declare const S: import("../api.js").NamedUnit;
+export declare const Wb: import("../api.js").NamedUnit;
+export declare const T: import("../api.js").NamedUnit;
+export declare const H: import("../api.js").NamedUnit;
+//# sourceMappingURL=electric.d.ts.map

package/{electric.js → units/electric.js}

@@ -1,7 +1,7 @@
 import { m2 } from "./area.js";
 import { J } from "./energy.js";
 import { h, s } from "./time.js";
-import { coherent, defUnit, div, mul, prefix } from "./unit.js";
+import { coherent, defUnit, div, mul, prefix } from "../unit.js";
 export const A = defUnit("A", "ampere", coherent(3));
 export const mA = defUnit("mA", "milliampere", prefix("m", A));
 export const mAh = defUnit("mAh", "milliampere-hour", mul(mA, h));

package/units/energy.d.ts

@@ -0,0 +1,7 @@
+export declare const J: import("../api.js").NamedUnit;
+export declare const kJ: import("../api.js").NamedUnit;
+export declare const MJ: import("../api.js").NamedUnit;
+export declare const GJ: import("../api.js").NamedUnit;
+export declare const cal: import("../api.js").NamedUnit;
+export declare const kcal: import("../api.js").NamedUnit;
+//# sourceMappingURL=energy.d.ts.map

package/{energy.js → units/energy.js}

@@ -1,6 +1,6 @@
 import { N } from "./force.js";
 import { m } from "./length.js";
-import { defUnit, mul, prefix } from "./unit.js";
+import { defUnit, mul, prefix } from "../unit.js";
 export const J = defUnit("J", "joule", mul(N, m, true));
 export const kJ = defUnit("kJ", "kilojoule", prefix("k", J));
 export const MJ = defUnit("MJ", "megajoule", prefix("M", J));

package/units/force.d.ts

@@ -0,0 +1,2 @@
+export declare const N: import("../api.js").NamedUnit;
+//# sourceMappingURL=force.d.ts.map

package/{force.js → units/force.js}

@@ -1,4 +1,4 @@
 import { m_s2 } from "./accel.js";
 import { kg } from "./mass.js";
-import { defUnit, mul } from "./unit.js";
+import { defUnit, mul } from "../unit.js";
 export const N = defUnit("N", "newton", mul(kg, m_s2, true));

package/units/frequency.d.ts

@@ -0,0 +1,9 @@
+export declare const Hz: import("../api.js").NamedUnit;
+export declare const kHz: import("../api.js").NamedUnit;
+export declare const MHz: import("../api.js").NamedUnit;
+export declare const GHz: import("../api.js").NamedUnit;
+export declare const THz: import("../api.js").NamedUnit;
+export declare const rpm: import("../api.js").NamedUnit;
+export declare const ω: import("../api.js").NamedUnit;
+export declare const omega: import("../api.js").NamedUnit;
+//# sourceMappingURL=frequency.d.ts.map

package/{frequency.js → units/frequency.js}

@@ -1,5 +1,5 @@
 import { s } from "./time.js";
-import { defUnit, div, mul, prefix, reciprocal } from "./unit.js";
+import { defUnit, div, mul, prefix, reciprocal } from "../unit.js";
 export const Hz = defUnit("Hz", "hertz", reciprocal(s, true));
 export const kHz = defUnit("kHz", "kilohertz", prefix("k", Hz));
 export const MHz = defUnit("MHz", "megahertz", prefix("M", Hz));

package/units/length.d.ts

@@ -0,0 +1,20 @@
+export declare const m: import("../api.js").NamedUnit;
+export declare const km: import("../api.js").NamedUnit;
+export declare const cm: import("../api.js").NamedUnit;
+export declare const mm: import("../api.js").NamedUnit;
+export declare const µm: import("../api.js").NamedUnit;
+export declare const nm: import("../api.js").NamedUnit;
+export declare const angstrom: import("../api.js").NamedUnit;
+export declare const au: import("../api.js").NamedUnit;
+export declare const ly: import("../api.js").NamedUnit;
+export declare const pc: import("../api.js").NamedUnit;
+export declare const inch: import("../api.js").NamedUnit;
+export declare const mil: import("../api.js").NamedUnit;
+export declare const thou: import("../api.js").NamedUnit;
+export declare const ft: import("../api.js").NamedUnit;
+export declare const yd: import("../api.js").NamedUnit;
+export declare const mi: import("../api.js").NamedUnit;
+export declare const nmi: import("../api.js").NamedUnit;
+export declare const pica: import("../api.js").NamedUnit;
+export declare const point: import("../api.js").NamedUnit;
+//# sourceMappingURL=length.d.ts.map

package/{length.js → units/length.js}

@@ -1,4 +1,4 @@
-import { coherent, defUnit, mul, prefix } from "./unit.js";
+import { coherent, defUnit, mul, prefix } from "../unit.js";
 export const m = defUnit("m", "meter", coherent(1));
 export const km = defUnit("km", "kilometer", prefix("k", m));
 export const cm = defUnit("cm", "centimeter", prefix("c", m));

package/units/luminous.d.ts

@@ -0,0 +1,4 @@
+export declare const cd: import("../api.js").NamedUnit;
+export declare const lm: import("../api.js").NamedUnit;
+export declare const lx: import("../api.js").NamedUnit;
+//# sourceMappingURL=luminous.d.ts.map