@thi.ng/units 0.1.1 → 0.3.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@thi.ng/units",
-  "version": "0.1.1",
-  "description": "Extensible SI unit creation, conversions & calculations (~150 units predefined)",
+  "version": "0.3.0",
+  "description": "Extensible SI unit creation, conversions, quantities & calculations (incl. ~170 predefined units & constants)",
   "type": "module",
   "module": "./index.js",
   "typings": "./index.d.ts",
@@ -34,6 +34,7 @@
     "test": "testament test"
   },
   "dependencies": {
+    "@thi.ng/api": "^8.7.4",
     "@thi.ng/checks": "^3.3.10",
     "@thi.ng/equiv": "^2.1.20",
     "@thi.ng/errors": "^2.2.13"
@@ -52,23 +53,27 @@
     "area",
     "bits",
     "bytes",
+    "calculation",
     "capacitance",
     "current",
     "voltage",
     "resistance",
-    "converter",
+    "conversion",
     "energy",
     "force",
     "frequency",
     "length",
     "mass",
+    "math",
     "power",
     "si",
     "speed",
+    "symbolic",
     "temperature",
     "time",
     "typescript",
     "units",
+    "velocity",
     "volume"
   ],
   "publishConfig": {
@@ -83,76 +88,96 @@
   },
   "files": [
     "./*.js",
-    "./*.d.ts"
+    "./*.d.ts",
+    "constants",
+    "units"
   ],
   "exports": {
     ".": {
       "default": "./index.js"
     },
-    "./accel": {
-      "default": "./accel.js"
-    },
-    "./angle": {
-      "default": "./angle.js"
-    },
     "./api": {
       "default": "./api.js"
     },
-    "./area": {
-      "default": "./area.js"
+    "./constants/densities": {
+      "default": "./constants/densities.js"
     },
-    "./data": {
-      "default": "./data.js"
+    "./constants/din-sizes": {
+      "default": "./constants/din-sizes.js"
     },
-    "./electric": {
-      "default": "./electric.js"
+    "./constants/earth": {
+      "default": "./constants/earth.js"
     },
-    "./energy": {
-      "default": "./energy.js"
+    "./constants/velocities": {
+      "default": "./constants/velocities.js"
     },
-    "./force": {
-      "default": "./force.js"
+    "./unit": {
+      "default": "./unit.js"
     },
-    "./frequency": {
-      "default": "./frequency.js"
+    "./units/accel": {
+      "default": "./units/accel.js"
     },
-    "./length": {
-      "default": "./length.js"
+    "./units/angle": {
+      "default": "./units/angle.js"
     },
-    "./luminous": {
-      "default": "./luminous.js"
+    "./units/area": {
+      "default": "./units/area.js"
     },
-    "./mass": {
-      "default": "./mass.js"
+    "./units/data": {
+      "default": "./units/data.js"
     },
-    "./power": {
-      "default": "./power.js"
+    "./units/density": {
+      "default": "./units/density.js"
     },
-    "./pressure": {
-      "default": "./pressure.js"
+    "./units/electric": {
+      "default": "./units/electric.js"
     },
-    "./speed": {
-      "default": "./speed.js"
+    "./units/energy": {
+      "default": "./units/energy.js"
     },
-    "./substance": {
-      "default": "./substance.js"
+    "./units/force": {
+      "default": "./units/force.js"
     },
-    "./temperature": {
-      "default": "./temperature.js"
+    "./units/frequency": {
+      "default": "./units/frequency.js"
     },
-    "./time": {
-      "default": "./time.js"
+    "./units/length": {
+      "default": "./units/length.js"
     },
-    "./unit": {
-      "default": "./unit.js"
+    "./units/luminous": {
+      "default": "./units/luminous.js"
+    },
+    "./units/mass": {
+      "default": "./units/mass.js"
+    },
+    "./units/parts": {
+      "default": "./units/parts.js"
+    },
+    "./units/power": {
+      "default": "./units/power.js"
+    },
+    "./units/pressure": {
+      "default": "./units/pressure.js"
+    },
+    "./units/substance": {
+      "default": "./units/substance.js"
+    },
+    "./units/temperature": {
+      "default": "./units/temperature.js"
+    },
+    "./units/time": {
+      "default": "./units/time.js"
+    },
+    "./units/velocity": {
+      "default": "./units/velocity.js"
     },
-    "./volume": {
-      "default": "./volume.js"
+    "./units/volume": {
+      "default": "./units/volume.js"
     }
   },
   "thi.ng": {
     "status": "beta",
     "year": 2021
   },
-  "gitHead": "ed05ea133992d4eb3a64fa02af0e85ac6ef07381\n"
+  "gitHead": "226659c410d47899bdc702e8cd871e2b66548bb8\n"
 }

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));