@thi.ng/units 0.4.18 → 0.4.19

package/unit.js

@@ -4,305 +4,176 @@ 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 { NONE, PREFIXES, } from "./api.js";
-/**
- * Cache/registry for all units defined via {@link defUnit}.
- */
-export const UNITS = {};
-/**
- * Defines a "raw" (anonymous) unit using given dimension(s), scale factor, zero
- * offset and `coherent` flag indicating if the unit is the coherent one for
- * given dimensions and can later be used for deriving prefixed versions (see
- * {@link coherent}).
- *
- * @param dim
- * @param scale
- * @param offset
- * @param coherent
- */
-export const unit = (dim, scale, offset = 0, coherent = false) => ({
-    dim: isNumber(dim) ? __oneHot(dim) : dim,
-    scale,
-    offset,
-    coherent,
+import {
+  NONE,
+  PREFIXES
+} from "./api.js";
+const UNITS = {};
+const unit = (dim, scale, offset = 0, coherent2 = false) => ({
+  dim: isNumber(dim) ? __oneHot(dim) : dim,
+  scale,
+  offset,
+  coherent: coherent2
 });
-/**
- * Syntax sugar for defining coherent SI base units. See {@link unit}.
- *
- * @param dim
- */
-export const coherent = (dim) => unit(dim, 1, 0, true);
-/**
- * Returns a new dimensionless unit (i.e. all SI dimensions are zero) with given
- * `scale` factor.
- *
- * @param scale
- * @param offset
- * @param 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.
- *
- * @remarks
- * By default throws an error if attempting to register a unit with an existing
- * symbol. If `force` is true, the existing unit will be overwritten.
- *
- * @param sym
- * @param name
- * @param unit
- * @param force
- */
-export const defUnit = (sym, name, unit, force = false) => {
-    if (UNITS[sym] && !force)
-        illegalArgs(`attempt to override unit: ${sym}`);
-    return (UNITS[sym] = { ...unit, sym, name });
+const coherent = (dim) => unit(dim, 1, 0, true);
+const dimensionless = (scale, offset = 0, coherent2 = false) => unit(NONE.dim, scale, offset, coherent2);
+const defUnit = (sym, name, unit2, force = false) => {
+  if (UNITS[sym] && !force)
+    illegalArgs(`attempt to override unit: ${sym}`);
+  return UNITS[sym] = { ...unit2, sym, name };
 };
-/**
- * Attempts to find a unit by given symbol ID/name. Throws error if unit is
- * unknown.
- *
- * @param id
- */
-export const asUnit = (id) => {
-    for (let i = 0; i < id.length; i++) {
-        const pre = id.substring(0, i);
-        const unit = UNITS[id.substring(i)];
-        if (unit) {
-            return PREFIXES[pre] !== undefined
-                ? prefix(pre, unit)
-                : !pre
-                    ? unit
-                    : illegalArgs(`unknown unit: ${id}`);
-        }
+const asUnit = (id) => {
+  for (let i = 0; i < id.length; i++) {
+    const pre = id.substring(0, i);
+    const unit2 = UNITS[id.substring(i)];
+    if (unit2) {
+      return PREFIXES[pre] !== void 0 ? prefix(pre, unit2) : !pre ? unit2 : illegalArgs(`unknown unit: ${id}`);
     }
-    for (let u in UNITS) {
-        if (UNITS[u].name === id)
-            return UNITS[u];
-    }
-    illegalArgs(`unknown unit: ${id}`);
+  }
+  for (let u in UNITS) {
+    if (UNITS[u].name === id)
+      return UNITS[u];
+  }
+  illegalArgs(`unknown unit: ${id}`);
 };
-/**
- * Creates a new re-scaled version of given unit (only coherent ones are
- * allowed), using the scale factor associated with given standard metric prefix
- * (see {@link PREFIXES}). If `coherent` is true (default: false), the new unit
- * itself is considered coherent and can be prefixed later.
- *
- * @example
- * ```ts
- * // create kilometer unit from (builtin) meter
- * const KM = prefix("k", M);
- * ```
- *
- * @param id
- * @param unit
- * @param coherent
- */
-export const prefix = (id, unit, coherent = false) => {
-    const $u = __ensureUnit(unit);
-    return $u.coherent
-        ? mul($u, PREFIXES[id], coherent)
-        : illegalArgs("unit isn't coherent");
+const prefix = (id, unit2, coherent2 = false) => {
+  const $u = __ensureUnit(unit2);
+  return $u.coherent ? mul($u, PREFIXES[id], coherent2) : illegalArgs("unit isn't coherent");
 };
-/**
- * Wrapper for scalar or vector quantities. See {@link quantity}.
- */
-export class Quantity {
-    value;
-    constructor(value) {
-        this.value = value;
-    }
-    deref() {
-        return ((isArray(this.value)
-            ? this.value.map((x) => x.scale)
-            : this.value.scale));
-    }
+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.
- *
- * @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 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))
-        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);
+const quantity = (value, unit2) => new Quantity(
+  isNumber(value) ? mul(unit2, value) : value.map((x) => mul(unit2, x))
+);
+function mul(a, b, coherent2 = false) {
+  if (a instanceof Quantity)
+    return __combineQ(mul, a, b);
+  const $a = __ensureUnit(a);
+  if (isNumber(b))
+    return unit($a.dim, $a.scale * b, $a.offset, coherent2);
+  const $b = __ensureUnit(b);
+  return unit(
+    $a.dim.map((x, i) => x + $b.dim[i]),
+    $a.scale * $b.scale,
+    0,
+    coherent2
+  );
 }
-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);
+function div(a, b, coherent2 = 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, coherent2);
+  }
+  const $b = __ensureUnit(b);
+  return unit(
+    $a.dim.map((x, i) => x - $b.dim[i]),
+    $a.scale / $b.scale,
+    0,
+    coherent2
+  );
 }
-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);
+function reciprocal(u, coherent2 = false) {
+  return u instanceof Quantity ? new Quantity(
+    isArray(u.value) ? u.value.map((x) => div(NONE, x)) : div(NONE, u.value)
+  ) : div(NONE, u, coherent2);
 }
-/**
- * Raises given unit to power `k`. If `coherent` is true (default: false), the
- * new unit itself is considered coherent and can be prefixed later.
- *
- * ```ts
- * // create kilometer unit from (builtin) meter
- * const SQ_METER = pow(M, 2);
- *
- * // acceleration aka m/s^2
- * const M_S2 = div(M, pow(S, 2));
- * ```
- *
- * @param u
- * @param k
- * @param coherent
- */
-export const pow = (u, k, coherent = false) => {
-    const $u = __ensureUnit(u);
-    return unit($u.dim.map((x) => x * k), $u.scale ** k, 0, coherent);
+const pow = (u, k, coherent2 = false) => {
+  const $u = __ensureUnit(u);
+  return unit(
+    $u.dim.map((x) => x * k),
+    $u.scale ** k,
+    0,
+    coherent2
+  );
 };
-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;
+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` 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);
+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 quantity or unit.
- *
- * @param u
- */
-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).
- *
- * @param a
- * @param b
- */
-export const isReciprocal = (a, b) => {
-    const { dim: $a } = __ensureUnit(a);
-    const { dim: $b } = __ensureUnit(b);
-    let ok = false;
-    for (let i = 0; i < 7; i++) {
-        const xa = $a[i];
-        const xb = $b[i];
-        if (xa === 0 && xb === 0)
-            continue;
-        if (xa !== -xb)
-            return false;
-        ok = true;
-    }
-    return ok;
+const isDimensionless = (u) => u instanceof Quantity ? isDimensionless(__qunit(u)) : __ensureUnit(u).dim.every((x) => x === 0);
+const isReciprocal = (a, b) => {
+  const { dim: $a } = __ensureUnit(a);
+  const { dim: $b } = __ensureUnit(b);
+  let ok = false;
+  for (let i = 0; i < 7; i++) {
+    const xa = $a[i];
+    const xb = $b[i];
+    if (xa === 0 && xb === 0)
+      continue;
+    if (xa !== -xb)
+      return false;
+    ok = true;
+  }
+  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 = [];
-    for (let i = 0; i < 7; i++) {
-        const x = dim[i];
-        if (x !== 0)
-            acc.push(SI[i] + (x !== 1 ? x : ""));
-    }
-    return acc.length ? acc.join("·") : "<dimensionless>";
+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 = [];
+  for (let i = 0; i < 7; i++) {
+    const x = dim[i];
+    if (x !== 0)
+      acc.push(SI[i] + (x !== 1 ? x : ""));
+  }
+  return acc.length ? acc.join("\xB7") : "<dimensionless>";
 };
-/** @internal */
-const __ensureUnit = (x) => (isString(x) ? asUnit(x) : x);
-/** @internal */
+const __ensureUnit = (x) => isString(x) ? asUnit(x) : x;
 const __oneHot = (x) => {
-    const dims = new Array(7).fill(0);
-    dims[x] = 1;
-    return dims;
+  const dims = new Array(7).fill(0);
+  dims[x] = 1;
+  return dims;
 };
-const __qunit = (q) => (isArray(q.value) ? q.value[0] : q.value);
+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));
+  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)
+  );
+};
+export {
+  Quantity,
+  UNITS,
+  asUnit,
+  coherent,
+  convert,
+  defUnit,
+  dimensionless,
+  div,
+  formatSI,
+  isConvertible,
+  isDimensionless,
+  isReciprocal,
+  mul,
+  pow,
+  prefix,
+  quantity,
+  reciprocal,
+  unit
 };

package/units/accel.js

@@ -3,7 +3,17 @@ import { ft, m } from "./length.js";
 import { s } from "./time.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));
-export const rad_s2 = defUnit("rad/s2", "radian per second squared", div(rad, s2));
-export const g0 = defUnit("g0", "standard gravity", mul(m_s2, 9.80665));
+const m_s2 = defUnit("m/s2", "meter per second squared", div(m, s2));
+const ft_s2 = defUnit("ft/s2", "foot per second squared", div(ft, s2));
+const rad_s2 = defUnit(
+  "rad/s2",
+  "radian per second squared",
+  div(rad, s2)
+);
+const g0 = defUnit("g0", "standard gravity", mul(m_s2, 9.80665));
+export {
+  ft_s2,
+  g0,
+  m_s2,
+  rad_s2
+};

package/units/angle.js

@@ -1,9 +1,18 @@
 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));
-export const gon = defUnit("gon", "gradian", mul(rad, PI / 200));
-export const turn = defUnit("turn", "turn", mul(rad, 2 * PI));
-export const arcmin = defUnit("arcmin", "arc minute", mul(rad, PI / 10800));
-export const arcsec = defUnit("arcsec", "arc second", mul(rad, PI / 648000));
-export const sr = defUnit("sr", "steradian", dimensionless(1, 0, true));
+const rad = defUnit("rad", "radian", dimensionless(1, 0, true));
+const deg = defUnit("deg", "degree", mul(rad, PI / 180));
+const gon = defUnit("gon", "gradian", mul(rad, PI / 200));
+const turn = defUnit("turn", "turn", mul(rad, 2 * PI));
+const arcmin = defUnit("arcmin", "arc minute", mul(rad, PI / 10800));
+const arcsec = defUnit("arcsec", "arc second", mul(rad, PI / 648e3));
+const sr = defUnit("sr", "steradian", dimensionless(1, 0, true));
+export {
+  arcmin,
+  arcsec,
+  deg,
+  gon,
+  rad,
+  sr,
+  turn
+};

package/units/area.js

@@ -1,11 +1,22 @@
 import { cm, ft, inch, km, m, mi, mm } from "./length.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));
-export const km2 = defUnit("km2", "square kilometer", pow(km, 2));
-export const ha = defUnit("ha", "hectar", mul(m2, 1e4));
-export const ac = defUnit("ac", "acre", mul(m2, 4046.86));
-export const sqin = defUnit("sqin", "square inch", pow(inch, 2));
-export const sqft = defUnit("sqft", "square foot", pow(ft, 2));
-export const sqmi = defUnit("sqmi", "square mile", pow(mi, 2));
+const m2 = defUnit("m2", "square meter", pow(m, 2));
+const mm2 = defUnit("mm2", "square millimeter", pow(mm, 2));
+const cm2 = defUnit("cm2", "square centimeter", pow(cm, 2));
+const km2 = defUnit("km2", "square kilometer", pow(km, 2));
+const ha = defUnit("ha", "hectar", mul(m2, 1e4));
+const ac = defUnit("ac", "acre", mul(m2, 4046.86));
+const sqin = defUnit("sqin", "square inch", pow(inch, 2));
+const sqft = defUnit("sqft", "square foot", pow(ft, 2));
+const sqmi = defUnit("sqmi", "square mile", pow(mi, 2));
+export {
+  ac,
+  cm2,
+  ha,
+  km2,
+  m2,
+  mm2,
+  sqft,
+  sqin,
+  sqmi
+};

package/units/data.js

@@ -1,26 +1,51 @@
 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));
-export const Gbit = defUnit("Gbit", "gigabit", prefix("G", bit));
-export const Tbit = defUnit("Tbit", "terabit", prefix("T", bit));
-export const B = defUnit("B", "byte", mul(bit, 8, true));
-export const kB = defUnit("kB", "kilobyte", prefix("k", B));
-export const MB = defUnit("MB", "megabyte", prefix("M", B));
-export const GB = defUnit("GB", "gigabyte", prefix("G", B));
-export const TB = defUnit("TB", "terabyte", prefix("T", B));
-export const PB = defUnit("PB", "petabyte", prefix("P", B));
-export const EB = defUnit("EB", "exabyte", prefix("E", B));
-// https://en.wikipedia.org/wiki/Byte#Multiple-byte_units
-export const Kibit = defUnit("Kibit", "kibibit", mul(bit, 1024));
-export const Mibit = defUnit("Mibit", "mebibit", mul(Kibit, 1024));
-export const Gibit = defUnit("Gibit", "gibibit", mul(Mibit, 1024));
-export const Tibit = defUnit("Tibit", "tebibit", mul(Gibit, 1024));
-export const Pibit = defUnit("Pibit", "pebibit", mul(Tibit, 1024));
-export const Eibit = defUnit("Eibit", "exbibit", mul(Pibit, 1024));
-export const KiB = defUnit("KiB", "kibibyte", mul(B, 1024));
-export const MiB = defUnit("MiB", "mebibyte", mul(KiB, 1024));
-export const GiB = defUnit("GiB", "gibibyte", mul(MiB, 1024));
-export const TiB = defUnit("TiB", "tebibyte", mul(GiB, 1024));
-export const PiB = defUnit("PiB", "pebibyte", mul(TiB, 1024));
-export const EiB = defUnit("EiB", "exbibyte", mul(PiB, 1024));
+const bit = defUnit("bit", "bit", dimensionless(1, 0, true));
+const kbit = defUnit("kbit", "kilobit", prefix("k", bit));
+const Mbit = defUnit("Mbit", "megabit", prefix("M", bit));
+const Gbit = defUnit("Gbit", "gigabit", prefix("G", bit));
+const Tbit = defUnit("Tbit", "terabit", prefix("T", bit));
+const B = defUnit("B", "byte", mul(bit, 8, true));
+const kB = defUnit("kB", "kilobyte", prefix("k", B));
+const MB = defUnit("MB", "megabyte", prefix("M", B));
+const GB = defUnit("GB", "gigabyte", prefix("G", B));
+const TB = defUnit("TB", "terabyte", prefix("T", B));
+const PB = defUnit("PB", "petabyte", prefix("P", B));
+const EB = defUnit("EB", "exabyte", prefix("E", B));
+const Kibit = defUnit("Kibit", "kibibit", mul(bit, 1024));
+const Mibit = defUnit("Mibit", "mebibit", mul(Kibit, 1024));
+const Gibit = defUnit("Gibit", "gibibit", mul(Mibit, 1024));
+const Tibit = defUnit("Tibit", "tebibit", mul(Gibit, 1024));
+const Pibit = defUnit("Pibit", "pebibit", mul(Tibit, 1024));
+const Eibit = defUnit("Eibit", "exbibit", mul(Pibit, 1024));
+const KiB = defUnit("KiB", "kibibyte", mul(B, 1024));
+const MiB = defUnit("MiB", "mebibyte", mul(KiB, 1024));
+const GiB = defUnit("GiB", "gibibyte", mul(MiB, 1024));
+const TiB = defUnit("TiB", "tebibyte", mul(GiB, 1024));
+const PiB = defUnit("PiB", "pebibyte", mul(TiB, 1024));
+const EiB = defUnit("EiB", "exbibyte", mul(PiB, 1024));
+export {
+  B,
+  EB,
+  EiB,
+  Eibit,
+  GB,
+  Gbit,
+  GiB,
+  Gibit,
+  KiB,
+  Kibit,
+  MB,
+  Mbit,
+  MiB,
+  Mibit,
+  PB,
+  PiB,
+  Pibit,
+  TB,
+  Tbit,
+  TiB,
+  Tibit,
+  bit,
+  kB,
+  kbit
+};

package/units/density.js

@@ -2,5 +2,9 @@ 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));
+const kg_m3 = defUnit("kg/m3", "kilogram per cubic meter", div(kg, m3));
+const dpi = defUnit("dpi", "dots per inch", reciprocal(inch));
+export {
+  dpi,
+  kg_m3
+};