@danielsimonjr/mathts-core 0.18.1 → 0.20.0

package/dist/index.js

@@ -1,1598 +1,1412 @@
-import {
-  BIGNUMBER_E,
-  BIGNUMBER_LN10,
-  BIGNUMBER_LN2,
-  BIGNUMBER_NEG_ONE,
-  BIGNUMBER_ONE,
-  BIGNUMBER_PI,
-  BIGNUMBER_TEN,
-  BIGNUMBER_ZERO,
-  BigNumber,
-  COMPLEX_NEG_ONE,
-  COMPLEX_ONE,
-  COMPLEX_ZERO,
-  Complex,
-  DimensionMismatchError,
-  FRACTION_HALF,
-  FRACTION_NEG_ONE,
-  FRACTION_ONE,
-  FRACTION_QUARTER,
-  FRACTION_THIRD,
-  FRACTION_ZERO,
-  Fraction,
-  I,
-  LN2_EXACT_SCALE,
-  NAMED_IRRATIONALS,
-  NAMED_SCALES,
-  PI_EXACT_SCALE,
-  UNIT_EXACT_SCALE,
-  UNIT_PREFIX_SETS,
-  UNIT_ROWS,
-  UNIT_ROW_ALIASES,
-  Unit,
-  UnitParseError,
-  abs,
-  addExactScales,
-  addScalar,
-  binaryExactScale,
-  clearExactScaleNumberCache,
-  decimalExactScale,
-  divideExactScales,
-  divideScalar,
-  equal,
-  exactScaleNumberCacheSize,
-  exactScaleOf,
-  exactScaleToNumber,
-  exactScalesEqual,
-  factory,
-  fix,
-  format,
-  formatExactScale,
-  getUnitPrefix,
-  getUnitRow,
-  irrationalPower,
-  isBigInt,
-  isBigNumber,
-  isBigNumber2,
-  isComplex2 as isComplex,
-  isFraction2 as isFraction,
-  isNumeric,
-  isRationalScale,
-  isUnit,
-  multiplyExactScales,
-  multiplyScalar,
-  namedExactScale,
-  namedIrrationalScale,
-  nearlyEqual,
-  number,
-  pow,
-  powerExactScale,
-  ratioExactScale,
-  readScaleExpression,
-  readUnitScale,
-  round,
-  sign,
-  subtractScalar,
-  unitPrefixExactScale,
-  unitRowExactOffset,
-  unitRowExactScale,
-  unitRowValue
-} from "./chunk-36FOYJAP.js";
-
-// src/types/matrix/Range.ts
-var name = "Range";
-var dependencies = [];
-var createRangeClass = /* @__PURE__ */ factory(
-  name,
-  dependencies,
-  () => {
-    class Range2 {
-      /**
-       * Type identifier
-       */
-      type = "Range";
-      /**
-       * Range type flag
-       */
-      isRange = true;
-      /**
-       * Start value of the range (inclusive)
-       */
-      start;
-      /**
-       * End value of the range (exclusive)
-       */
-      end;
-      /**
-       * Step size for the range
-       */
-      step;
-      /**
-       * Cached primitive array representation.
-       *
-       * @internal Not part of the public API.
-       *
-       * These four were ES-private (`#cache`) until TypeScript 7. This class is
-       * returned from a `factory()` call, so declaration emit describes it as an
-       * ANONYMOUS class type -- and TS4094 forbids private or protected members
-       * there, because an anonymous type has no name to refer them to. The
-       * underscore prefix keeps the "do not touch" signal without the emit
-       * failure. Restore `#` if the class is ever hoisted out of the factory.
-       */
-      _cache = null;
-      _cacheStart;
-      _cacheEnd;
-      _cacheStep;
-      /**
-       * Create a range from start to end with a step.
-       *
-       * @param start - Included lower bound. Default is 0.
-       * @param end - Excluded upper bound. Default is 0.
-       * @param step - Optional step size. Default is 1.
-       * @throws TypeError when start, end or step is not a number, bigint or BigNumber.
-       * @throws Error when step is zero.
-       */
-      constructor(start, end, step) {
-        if (!(this instanceof Range2)) {
-          throw new SyntaxError("Constructor must be called with the new operator");
-        }
-        const hasStart = start !== null && start !== void 0;
-        const hasEnd = end !== null && end !== void 0;
-        const hasStep = step !== null && step !== void 0;
-        let startValue = 0;
-        let endValue = 0;
-        let stepValue = 1;
-        if (hasStart) {
-          if (isBigNumber(start)) {
-            startValue = start.toNumber();
-          } else if (typeof start !== "number" && !isBigInt(start)) {
-            throw new TypeError("Parameter start must be a number or bigint");
-          } else {
-            startValue = start;
-          }
-        }
-        if (hasEnd) {
-          if (isBigNumber(end)) {
-            endValue = end.toNumber();
-          } else if (typeof end !== "number" && !isBigInt(end)) {
-            throw new TypeError("Parameter end must be a number or bigint");
-          } else {
-            endValue = end;
-          }
-        }
-        if (hasStep) {
-          if (isBigNumber(step)) {
-            stepValue = step.toNumber();
-          } else if (typeof step !== "number" && !isBigInt(step)) {
-            throw new TypeError("Parameter step must be a number or bigint");
-          } else {
-            stepValue = step;
-          }
-        }
-        this.start = hasStart ? parseFloat(startValue.toString()) : 0;
-        this.end = hasEnd ? parseFloat(endValue.toString()) : 0;
-        this.step = hasStep ? parseFloat(stepValue.toString()) : 1;
-        if (hasStep && nearlyEqual(this.step, 0)) {
-          throw new Error("Step must not be zero");
-        }
-      }
-      /**
-       * Parse a string into a range,
-       * The string contains the start, optional step, and end, separated by a colon.
-       * If the string does not contain a valid range, null is returned.
-       * For example str='0:2:11'.
-       * @memberof Range
-       * @param str
-       * @return range
-       */
-      static parse(str) {
-        if (typeof str !== "string") {
-          return null;
-        }
-        const args = str.split(":");
-        const nums = args.map(function(arg) {
-          return parseFloat(arg);
-        });
-        const invalid = nums.some(function(num) {
-          return isNaN(num);
-        });
-        if (invalid) {
-          return null;
-        }
-        switch (nums.length) {
-          case 2:
-            return new Range2(nums[0], nums[1]);
-          case 3:
-            return new Range2(nums[0], nums[2], nums[1]);
-          default:
-            return null;
-        }
-      }
-      /**
-       * Create a clone of the range
-       * @return clone
-       */
-      clone() {
-        return new Range2(this.start, this.end, this.step);
-      }
-      /**
-       * Retrieve the size of the range.
-       * Returns an array containing one number, the number of elements in the range.
-       * @memberof Range
-       * @returns size
-       */
-      size() {
-        let len = 0;
-        const start = this.start;
-        const step = this.step;
-        const end = this.end;
-        const diff = end - start;
-        if (sign(step) === sign(diff)) {
-          len = Math.ceil(diff / step);
-        } else if (diff === 0) {
-          len = 0;
-        }
-        if (isNaN(len)) {
-          len = 0;
-        }
-        return [len];
-      }
-      /**
-       * Calculate the minimum value in the range
-       * @memberof Range
-       * @return min
-       */
-      min() {
-        const size = this.size()[0];
-        if (size > 0) {
-          if (this.step > 0) {
-            return this.start;
-          } else {
-            return this.start + (size - 1) * this.step;
-          }
-        } else {
-          return void 0;
-        }
-      }
-      /**
-       * Calculate the maximum value in the range
-       * @memberof Range
-       * @return max
-       */
-      max() {
-        const size = this.size()[0];
-        if (size > 0) {
-          if (this.step > 0) {
-            return this.start + (size - 1) * this.step;
-          } else {
-            return this.start;
-          }
-        } else {
-          return void 0;
-        }
-      }
-      /**
-       * Execute a callback function for each value in the range.
-       * @memberof Range
-       * @param callback - The callback method is invoked with three
-       *                            parameters: the value of the element, the index
-       *                            of the element, and the Range being traversed.
-       */
-      forEach(callback) {
-        let x = this.start;
-        const step = this.step;
-        const end = this.end;
-        let i = 0;
-        if (step > 0) {
-          while (x < end) {
-            callback(x, [i], this);
-            x += step;
-            i++;
-          }
-        } else if (step < 0) {
-          while (x > end) {
-            callback(x, [i], this);
-            x += step;
-            i++;
-          }
-        }
-      }
-      /**
-       * Execute a callback function for each value in the Range, and return the
-       * results as an array
-       * @memberof Range
-       * @param callback - The callback method is invoked with three
-       *                            parameters: the value of the element, the index
-       *                            of the element, and the Matrix being traversed.
-       * @returns array
-       */
-      map(callback) {
-        const array = [];
-        this.forEach((value, index) => {
-          array[index[0]] = callback(value, index, this);
-        });
-        return array;
-      }
-      /**
-       * Create an Array with a copy of the Ranges data
-       * @memberof Range
-       * @returns array
-       */
-      toArray() {
-        const array = [];
-        this.forEach(function(value, index) {
-          array[index[0]] = value;
-        });
-        return array;
-      }
-      /**
-       * Get the primitive value of the Range, a one dimensional array
-       * @memberof Range
-       * @returns array
-       */
-      valueOf() {
-        if (this._cache !== null && this.start === this._cacheStart && this.end === this._cacheEnd && this.step === this._cacheStep) {
-          return this._cache;
-        }
-        this._cache = this.toArray();
-        this._cacheStart = this.start;
-        this._cacheEnd = this.end;
-        this._cacheStep = this.step;
-        return this._cache;
-      }
-      /**
-       * Get a string representation of the range, with optional formatting options.
-       * Output is formatted as 'start:step:end', for example '2:6' or '0:0.2:11'
-       * @memberof Range
-       * @param options - Optional. Formatting options. See
-       *                                               lib/utils/number:format for a
-       *                                               description of the available
-       *                                               options.
-       * @returns str
-       */
-      format(options) {
-        let str = format(this.start, options);
-        if (this.step !== 1) {
-          str += ":" + format(this.step, options);
-        }
-        str += ":" + format(this.end, options);
-        return str;
-      }
-      /**
-       * Get a string representation of the range.
-       * @memberof Range
-       * @returns
-       */
-      toString() {
-        return this.format();
-      }
-      /**
-       * Get a JSON representation of the range
-       * @memberof Range
-       * @returns Returns a JSON object structured as:
-       *                   `{"mathjs": "Range", "start": 2, "end": 4, "step": 1}`
-       */
-      toJSON() {
-        return {
-          mathjs: "Range",
-          start: this.start,
-          end: this.end,
-          step: this.step
-        };
-      }
-      /**
-       * Instantiate a Range from a JSON object
-       * @memberof Range
-       * @param json - A JSON object structured as:
-       *                      `{"mathjs": "Range", "start": 2, "end": 4, "step": 1}`
-       * @return
-       */
-      static fromJSON(json) {
-        return new Range2(json.start, json.end, json.step);
-      }
-    }
-    return Range2;
-  },
-  { isClass: true }
-);
-var Range = createRangeClass({});
-
-// src/types/dual-rules.ts
-var DUAL_UNARY_RULES = {
-  exp: { primal: Math.exp, deriv: (_x, y) => y },
-  expm1: { primal: Math.expm1, deriv: (_x, y) => y + 1 },
-  log: { primal: Math.log, deriv: (x) => 1 / x },
-  log2: { primal: Math.log2, deriv: (x) => 1 / (x * Math.LN2) },
-  log10: { primal: Math.log10, deriv: (x) => 1 / (x * Math.LN10) },
-  log1p: { primal: Math.log1p, deriv: (x) => 1 / (1 + x) },
-  sin: { primal: Math.sin, deriv: (x) => Math.cos(x) },
-  cos: { primal: Math.cos, deriv: (x) => -Math.sin(x) },
-  tan: { primal: Math.tan, deriv: (x) => 1 / (Math.cos(x) * Math.cos(x)) },
-  asin: { primal: Math.asin, deriv: (x) => 1 / Math.sqrt(1 - x * x) },
-  acos: { primal: Math.acos, deriv: (x) => -1 / Math.sqrt(1 - x * x) },
-  atan: { primal: Math.atan, deriv: (x) => 1 / (1 + x * x) },
-  sinh: { primal: Math.sinh, deriv: (x) => Math.cosh(x) },
-  cosh: { primal: Math.cosh, deriv: (x) => Math.sinh(x) },
-  tanh: { primal: Math.tanh, deriv: (_x, y) => 1 - y * y },
-  asinh: { primal: Math.asinh, deriv: (x) => 1 / Math.sqrt(x * x + 1) },
-  acosh: { primal: Math.acosh, deriv: (x) => 1 / Math.sqrt(x * x - 1) },
-  atanh: { primal: Math.atanh, deriv: (x) => 1 / (1 - x * x) },
-  sqrt: { primal: Math.sqrt, deriv: (_x, y) => 1 / (2 * y) },
-  cbrt: { primal: Math.cbrt, deriv: (_x, y) => 1 / (3 * y * y) },
-  square: { primal: (x) => x * x, deriv: (x) => 2 * x },
-  reciprocal: { primal: (x) => 1 / x, deriv: (x) => -1 / (x * x) },
-  abs: { primal: Math.abs, deriv: (x) => Math.sign(x) },
-  sign: { primal: Math.sign, deriv: () => 0 }
+import { $ as BIGNUMBER_LN2, A as irrationalPower, B as addScalar, Bn as I, C as decimalExactScale, D as exactScaleToNumber, E as exactScaleOf, F as ratioExactScale, G as multiplyScalar, H as equal, I as readScaleExpression, In as COMPLEX_NEG_ONE, J as round, K as number, L as DimensionMismatchError, Ln as COMPLEX_ONE, M as multiplyExactScales, N as namedIrrationalScale, O as exactScalesEqual, P as powerExactScale, Pn as isUnit$1, Q as BIGNUMBER_LN10, R as UnitParseError, Rn as COMPLEX_ZERO, S as clearExactScaleNumberCache, T as exactScaleNumberCacheSize, U as fix, V as divideScalar, Vn as isComplex, W as isNumeric, Y as subtractScalar, Yt as format, Z as BIGNUMBER_E, _ as NAMED_IRRATIONALS, _t as factory, a as UNIT_PREFIX_SETS, an as sign, at as BigNumber, b as addExactScales, c as getUnitPrefix, ct as FRACTION_NEG_ONE, d as readUnitScale, dt as FRACTION_THIRD, et as BIGNUMBER_NEG_ONE, f as unitPrefixExactScale, ft as FRACTION_ZERO, g as LN2_EXACT_SCALE, h as unitRowValue, hn as isBigNumber$2, i as NAMED_SCALES, it as BIGNUMBER_ZERO, j as isRationalScale, k as formatExactScale, l as getUnitRow, lt as FRACTION_ONE, m as unitRowExactScale, mn as isBigInt$1, mt as isFraction, nt as BIGNUMBER_PI, o as UNIT_ROWS, ot as isBigNumber, p as unitRowExactOffset, pt as Fraction, q as pow, rt as BIGNUMBER_TEN, s as UNIT_ROW_ALIASES, st as FRACTION_HALF, t as Unit, tn as nearlyEqual, tt as BIGNUMBER_ONE, u as namedExactScale, ut as FRACTION_QUARTER, v as PI_EXACT_SCALE, w as divideExactScales, x as binaryExactScale, y as UNIT_EXACT_SCALE, z as abs, zn as Complex } from "./unit-Dul_E1rh.js";
+import typed, { create } from "typed-function";
+const createRangeClass = /* #__PURE__ */ factory("Range", [], () => {
+	class Range {
+		type = "Range";
+		isRange = true;
+		start;
+		end;
+		step;
+		_cache = null;
+		_cacheStart;
+		_cacheEnd;
+		_cacheStep;
+		constructor(start, end, step) {
+			if (!(this instanceof Range)) throw new SyntaxError("Constructor must be called with the new operator");
+			const hasStart = start !== null && start !== void 0;
+			const hasEnd = end !== null && end !== void 0;
+			const hasStep = step !== null && step !== void 0;
+			let startValue = 0;
+			let endValue = 0;
+			let stepValue = 1;
+			if (hasStart) {
+				if (isBigNumber$2(start)) startValue = start.toNumber();
+				else if (typeof start !== "number" && !isBigInt$1(start)) throw new TypeError("Parameter start must be a number or bigint");
+				else startValue = start;
+			}
+			if (hasEnd) {
+				if (isBigNumber$2(end)) endValue = end.toNumber();
+				else if (typeof end !== "number" && !isBigInt$1(end)) throw new TypeError("Parameter end must be a number or bigint");
+				else endValue = end;
+			}
+			if (hasStep) {
+				if (isBigNumber$2(step)) stepValue = step.toNumber();
+				else if (typeof step !== "number" && !isBigInt$1(step)) throw new TypeError("Parameter step must be a number or bigint");
+				else stepValue = step;
+			}
+			this.start = hasStart ? parseFloat(startValue.toString()) : 0;
+			this.end = hasEnd ? parseFloat(endValue.toString()) : 0;
+			this.step = hasStep ? parseFloat(stepValue.toString()) : 1;
+			if (hasStep && nearlyEqual(this.step, 0)) throw new Error("Step must not be zero");
+		}
+		static parse(str) {
+			if (typeof str !== "string") return null;
+			const nums = str.split(":").map(function(arg) {
+				return parseFloat(arg);
+			});
+			if (nums.some(function(num) {
+				return isNaN(num);
+			})) return null;
+			switch (nums.length) {
+				case 2: return new Range(nums[0], nums[1]);
+				case 3: return new Range(nums[0], nums[2], nums[1]);
+				default: return null;
+			}
+		}
+		clone() {
+			return new Range(this.start, this.end, this.step);
+		}
+		size() {
+			let len = 0;
+			const start = this.start;
+			const step = this.step;
+			const diff = this.end - start;
+			if (sign(step) === sign(diff)) len = Math.ceil(diff / step);
+			else if (diff === 0) len = 0;
+			if (isNaN(len)) len = 0;
+			return [len];
+		}
+		min() {
+			const size = this.size()[0];
+			if (size > 0) {
+				if (this.step > 0) return this.start;
+				else return this.start + (size - 1) * this.step;
+			} else return;
+		}
+		max() {
+			const size = this.size()[0];
+			if (size > 0) {
+				if (this.step > 0) return this.start + (size - 1) * this.step;
+				else return this.start;
+			} else return;
+		}
+		forEach(callback) {
+			let x = this.start;
+			const step = this.step;
+			const end = this.end;
+			let i = 0;
+			if (step > 0) while (x < end) {
+				callback(x, [i], this);
+				x += step;
+				i++;
+			}
+			else if (step < 0) while (x > end) {
+				callback(x, [i], this);
+				x += step;
+				i++;
+			}
+		}
+		map(callback) {
+			const array = [];
+			this.forEach((value, index) => {
+				array[index[0]] = callback(value, index, this);
+			});
+			return array;
+		}
+		toArray() {
+			const array = [];
+			this.forEach(function(value, index) {
+				array[index[0]] = value;
+			});
+			return array;
+		}
+		valueOf() {
+			if (this._cache !== null && this.start === this._cacheStart && this.end === this._cacheEnd && this.step === this._cacheStep) return this._cache;
+			this._cache = this.toArray();
+			this._cacheStart = this.start;
+			this._cacheEnd = this.end;
+			this._cacheStep = this.step;
+			return this._cache;
+		}
+		format(options) {
+			let str = format(this.start, options);
+			if (this.step !== 1) str += ":" + format(this.step, options);
+			str += ":" + format(this.end, options);
+			return str;
+		}
+		toString() {
+			return this.format();
+		}
+		toJSON() {
+			return {
+				mathjs: "Range",
+				start: this.start,
+				end: this.end,
+				step: this.step
+			};
+		}
+		static fromJSON(json) {
+			return new Range(json.start, json.end, json.step);
+		}
+	}
+	return Range;
+}, { isClass: true });
+const Range = createRangeClass({});
+//#endregion
+//#region src/types/dual-rules.ts
+const DUAL_UNARY_RULES = {
+	exp: {
+		primal: Math.exp,
+		deriv: (_x, y) => y
+	},
+	expm1: {
+		primal: Math.expm1,
+		deriv: (_x, y) => y + 1
+	},
+	log: {
+		primal: Math.log,
+		deriv: (x) => 1 / x
+	},
+	log2: {
+		primal: Math.log2,
+		deriv: (x) => 1 / (x * Math.LN2)
+	},
+	log10: {
+		primal: Math.log10,
+		deriv: (x) => 1 / (x * Math.LN10)
+	},
+	log1p: {
+		primal: Math.log1p,
+		deriv: (x) => 1 / (1 + x)
+	},
+	sin: {
+		primal: Math.sin,
+		deriv: (x) => Math.cos(x)
+	},
+	cos: {
+		primal: Math.cos,
+		deriv: (x) => -Math.sin(x)
+	},
+	tan: {
+		primal: Math.tan,
+		deriv: (x) => 1 / (Math.cos(x) * Math.cos(x))
+	},
+	asin: {
+		primal: Math.asin,
+		deriv: (x) => 1 / Math.sqrt(1 - x * x)
+	},
+	acos: {
+		primal: Math.acos,
+		deriv: (x) => -1 / Math.sqrt(1 - x * x)
+	},
+	atan: {
+		primal: Math.atan,
+		deriv: (x) => 1 / (1 + x * x)
+	},
+	sinh: {
+		primal: Math.sinh,
+		deriv: (x) => Math.cosh(x)
+	},
+	cosh: {
+		primal: Math.cosh,
+		deriv: (x) => Math.sinh(x)
+	},
+	tanh: {
+		primal: Math.tanh,
+		deriv: (_x, y) => 1 - y * y
+	},
+	asinh: {
+		primal: Math.asinh,
+		deriv: (x) => 1 / Math.sqrt(x * x + 1)
+	},
+	acosh: {
+		primal: Math.acosh,
+		deriv: (x) => 1 / Math.sqrt(x * x - 1)
+	},
+	atanh: {
+		primal: Math.atanh,
+		deriv: (x) => 1 / (1 - x * x)
+	},
+	sqrt: {
+		primal: Math.sqrt,
+		deriv: (_x, y) => 1 / (2 * y)
+	},
+	cbrt: {
+		primal: Math.cbrt,
+		deriv: (_x, y) => 1 / (3 * y * y)
+	},
+	square: {
+		primal: (x) => x * x,
+		deriv: (x) => 2 * x
+	},
+	reciprocal: {
+		primal: (x) => 1 / x,
+		deriv: (x) => -1 / (x * x)
+	},
+	abs: {
+		primal: Math.abs,
+		deriv: (x) => Math.sign(x)
+	},
+	sign: {
+		primal: Math.sign,
+		deriv: () => 0
+	}
 };
-
-// src/types/dual.ts
-var Dual = class _Dual {
-  /** Function value (the real part). */
-  value;
-  /** First derivative (the ε coefficient). */
-  deriv;
-  constructor(value, deriv = 0) {
-    this.value = value;
-    this.deriv = deriv;
-  }
-  /** A constant (derivative 0). */
-  static constant(v) {
-    return new _Dual(v, 0);
-  }
-  /** A seed variable (derivative 1) — the point of differentiation. */
-  static variable(v) {
-    return new _Dual(v, 1);
-  }
-  // --- arithmetic ----------------------------------------------------------
-  add(o) {
-    return new _Dual(this.value + o.value, this.deriv + o.deriv);
-  }
-  sub(o) {
-    return new _Dual(this.value - o.value, this.deriv - o.deriv);
-  }
-  mul(o) {
-    return new _Dual(this.value * o.value, this.deriv * o.value + this.value * o.deriv);
-  }
-  div(o) {
-    const d = (this.deriv * o.value - this.value * o.deriv) / (o.value * o.value);
-    return new _Dual(this.value / o.value, d);
-  }
-  neg() {
-    return new _Dual(-this.value, -this.deriv);
-  }
-  /** Power with a constant real exponent: d(xᵏ) = k·xᵏ⁻¹·dx. */
-  powConst(k) {
-    return new _Dual(Math.pow(this.value, k), this.deriv * k * Math.pow(this.value, k - 1));
-  }
-  /** General power a^b: d = a^b·(b'·ln a + b·a'/a). */
-  pow(o) {
-    const v = Math.pow(this.value, o.value);
-    const d = v * (o.deriv * Math.log(this.value) + o.value * this.deriv / this.value);
-    return new _Dual(v, d);
-  }
-  // --- elementary functions ------------------------------------------------
-  // Each applies the shared chain rule (value, deriv) ↦ (f(v), deriv·f′(v))
-  // using the canonical rule from `DUAL_UNARY_RULES`, so the scalar and tensor
-  // AD paths can never drift apart.
-  unary(rule) {
-    const y = rule.primal(this.value);
-    return new _Dual(y, this.deriv * rule.deriv(this.value, y));
-  }
-  sin() {
-    return this.unary(DUAL_UNARY_RULES.sin);
-  }
-  cos() {
-    return this.unary(DUAL_UNARY_RULES.cos);
-  }
-  tan() {
-    return this.unary(DUAL_UNARY_RULES.tan);
-  }
-  exp() {
-    return this.unary(DUAL_UNARY_RULES.exp);
-  }
-  log() {
-    return this.unary(DUAL_UNARY_RULES.log);
-  }
-  sqrt() {
-    return this.unary(DUAL_UNARY_RULES.sqrt);
-  }
-  square() {
-    return this.unary(DUAL_UNARY_RULES.square);
-  }
-  abs() {
-    return this.unary(DUAL_UNARY_RULES.abs);
-  }
-  sinh() {
-    return this.unary(DUAL_UNARY_RULES.sinh);
-  }
-  cosh() {
-    return this.unary(DUAL_UNARY_RULES.cosh);
-  }
-  tanh() {
-    return this.unary(DUAL_UNARY_RULES.tanh);
-  }
-  toString() {
-    return `Dual(${this.value}, ${this.deriv})`;
-  }
+//#endregion
+//#region src/types/dual.ts
+var Dual = class Dual {
+	value;
+	deriv;
+	constructor(value, deriv = 0) {
+		this.value = value;
+		this.deriv = deriv;
+	}
+	static constant(v) {
+		return new Dual(v, 0);
+	}
+	static variable(v) {
+		return new Dual(v, 1);
+	}
+	add(o) {
+		return new Dual(this.value + o.value, this.deriv + o.deriv);
+	}
+	sub(o) {
+		return new Dual(this.value - o.value, this.deriv - o.deriv);
+	}
+	mul(o) {
+		return new Dual(this.value * o.value, this.deriv * o.value + this.value * o.deriv);
+	}
+	div(o) {
+		const d = (this.deriv * o.value - this.value * o.deriv) / (o.value * o.value);
+		return new Dual(this.value / o.value, d);
+	}
+	neg() {
+		return new Dual(-this.value, -this.deriv);
+	}
+	powConst(k) {
+		return new Dual(Math.pow(this.value, k), this.deriv * k * Math.pow(this.value, k - 1));
+	}
+	pow(o) {
+		const v = Math.pow(this.value, o.value);
+		const d = v * (o.deriv * Math.log(this.value) + o.value * this.deriv / this.value);
+		return new Dual(v, d);
+	}
+	unary(rule) {
+		const y = rule.primal(this.value);
+		return new Dual(y, this.deriv * rule.deriv(this.value, y));
+	}
+	sin() {
+		return this.unary(DUAL_UNARY_RULES.sin);
+	}
+	cos() {
+		return this.unary(DUAL_UNARY_RULES.cos);
+	}
+	tan() {
+		return this.unary(DUAL_UNARY_RULES.tan);
+	}
+	exp() {
+		return this.unary(DUAL_UNARY_RULES.exp);
+	}
+	log() {
+		return this.unary(DUAL_UNARY_RULES.log);
+	}
+	sqrt() {
+		return this.unary(DUAL_UNARY_RULES.sqrt);
+	}
+	square() {
+		return this.unary(DUAL_UNARY_RULES.square);
+	}
+	abs() {
+		return this.unary(DUAL_UNARY_RULES.abs);
+	}
+	sinh() {
+		return this.unary(DUAL_UNARY_RULES.sinh);
+	}
+	cosh() {
+		return this.unary(DUAL_UNARY_RULES.cosh);
+	}
+	tanh() {
+		return this.unary(DUAL_UNARY_RULES.tanh);
+	}
+	toString() {
+		return `Dual(${this.value}, ${this.deriv})`;
+	}
 };
 function isDual(x) {
-  return x instanceof Dual;
+	return x instanceof Dual;
 }
-
-// src/constants.ts
-var PI = Math.PI;
-var E = Math.E;
-var TAU = 2 * Math.PI;
-var PHI = (1 + Math.sqrt(5)) / 2;
-var SQRT2 = Math.SQRT2;
-var SQRT1_2 = Math.SQRT1_2;
-var LN2 = Math.LN2;
-var LN10 = Math.LN10;
-var LOG2E = Math.LOG2E;
-var LOG10E = Math.LOG10E;
-
-// src/types/unit-definitions.ts
-var DIMENSIONLESS = Object.freeze({
-  length: 0,
-  mass: 0,
-  time: 0,
-  current: 0,
-  temperature: 0,
-  amount: 0,
-  luminosity: 0
+//#endregion
+//#region src/constants.ts
+const PI = Math.PI;
+const E = Math.E;
+const TAU = 2 * Math.PI;
+const PHI = (1 + Math.sqrt(5)) / 2;
+const SQRT2 = Math.SQRT2;
+const SQRT1_2 = Math.SQRT1_2;
+const LN2 = Math.LN2;
+const LN10 = Math.LN10;
+const LOG2E = Math.LOG2E;
+const LOG10E = Math.LOG10E;
+//#endregion
+//#region src/types/unit-definitions.ts
+const DIMENSIONLESS = Object.freeze({
+	length: 0,
+	mass: 0,
+	time: 0,
+	current: 0,
+	temperature: 0,
+	amount: 0,
+	luminosity: 0
 });
 function dim(partial) {
-  return {
-    length: partial.length ?? 0,
-    mass: partial.mass ?? 0,
-    time: partial.time ?? 0,
-    current: partial.current ?? 0,
-    temperature: partial.temperature ?? 0,
-    amount: partial.amount ?? 0,
-    luminosity: partial.luminosity ?? 0
-  };
+	return {
+		length: partial.length ?? 0,
+		mass: partial.mass ?? 0,
+		time: partial.time ?? 0,
+		current: partial.current ?? 0,
+		temperature: partial.temperature ?? 0,
+		amount: partial.amount ?? 0,
+		luminosity: partial.luminosity ?? 0
+	};
 }
-var BASE_UNITS = {
-  m: { multiplier: 1, dimensions: dim({ length: 1 }), prefixable: true },
-  // The base unit of mass is *kilogram*, but the prefix-able symbol is "g".
-  // Internally we treat 1 kg as the canonical value, so "g" -> 0.001 kg.
-  kg: { multiplier: 1, dimensions: dim({ mass: 1 }) },
-  s: { multiplier: 1, dimensions: dim({ time: 1 }), prefixable: true },
-  A: { multiplier: 1, dimensions: dim({ current: 1 }), prefixable: true },
-  K: { multiplier: 1, dimensions: dim({ temperature: 1 }), prefixable: true },
-  mol: { multiplier: 1, dimensions: dim({ amount: 1 }), prefixable: true },
-  cd: { multiplier: 1, dimensions: dim({ luminosity: 1 }), prefixable: true }
+const BASE_UNITS = {
+	m: {
+		multiplier: 1,
+		dimensions: dim({ length: 1 }),
+		prefixable: true
+	},
+	kg: {
+		multiplier: 1,
+		dimensions: dim({ mass: 1 })
+	},
+	s: {
+		multiplier: 1,
+		dimensions: dim({ time: 1 }),
+		prefixable: true
+	},
+	A: {
+		multiplier: 1,
+		dimensions: dim({ current: 1 }),
+		prefixable: true
+	},
+	K: {
+		multiplier: 1,
+		dimensions: dim({ temperature: 1 }),
+		prefixable: true
+	},
+	mol: {
+		multiplier: 1,
+		dimensions: dim({ amount: 1 }),
+		prefixable: true
+	},
+	cd: {
+		multiplier: 1,
+		dimensions: dim({ luminosity: 1 }),
+		prefixable: true
+	}
 };
-function tableUnit(name2, dimensions, prefixable) {
-  const row = getUnitRow(name2);
-  if (row === void 0) throw new Error(`unit-definitions: '${name2}' is not in the unit table`);
-  const scale = readUnitScale(row.scale);
-  const def = { multiplier: exactScaleToNumber(scale), dimensions };
-  if (row.offset !== void 0) {
-    def.offset = exactScaleToNumber(multiplyExactScales(scale, readUnitScale(row.offset)));
-  }
-  if (prefixable) def.prefixable = true;
-  return def;
+function tableUnit(name, dimensions, prefixable) {
+	const row = getUnitRow(name);
+	if (row === void 0) throw new Error(`unit-definitions: '${name}' is not in the unit table`);
+	const scale = readUnitScale(row.scale);
+	const def = {
+		multiplier: exactScaleToNumber(scale),
+		dimensions
+	};
+	if (row.offset !== void 0) def.offset = exactScaleToNumber(multiplyExactScales(scale, readUnitScale(row.offset)));
+	if (prefixable) def.prefixable = true;
+	return def;
 }
-var DERIVED_UNITS = {
-  // --- Length ---------------------------------------------------------------
-  // Note: 'm' is a base unit (above), already prefixable.
-  ft: tableUnit("ft", dim({ length: 1 })),
-  foot: tableUnit("foot", dim({ length: 1 })),
-  in: tableUnit("in", dim({ length: 1 })),
-  inch: tableUnit("inch", dim({ length: 1 })),
-  yd: tableUnit("yd", dim({ length: 1 })),
-  yard: tableUnit("yard", dim({ length: 1 })),
-  mi: tableUnit("mi", dim({ length: 1 })),
-  mile: tableUnit("mile", dim({ length: 1 })),
-  // --- Mass -----------------------------------------------------------------
-  // The "g" entry is gram (0.001 kg). It is prefixable, so kg/mg/µg work via
-  // prefix application on this entry rather than the base "kg".
-  g: tableUnit("g", dim({ mass: 1 }), true),
-  lb: tableUnit("lb", dim({ mass: 1 })),
-  lbm: tableUnit("lbm", dim({ mass: 1 })),
-  oz: tableUnit("oz", dim({ mass: 1 })),
-  ton: tableUnit("ton", dim({ mass: 1 })),
-  // US short ton
-  tonne: tableUnit("tonne", dim({ mass: 1 })),
-  // metric ton
-  // --- Time -----------------------------------------------------------------
-  min: tableUnit("min", dim({ time: 1 })),
-  h: tableUnit("h", dim({ time: 1 })),
-  hr: tableUnit("hr", dim({ time: 1 })),
-  day: tableUnit("day", dim({ time: 1 })),
-  week: tableUnit("week", dim({ time: 1 })),
-  year: tableUnit("year", dim({ time: 1 })),
-  // Julian year
-  // --- Temperature ----------------------------------------------------------
-  // K is the base.
-  // °C → K is offset by 273.15 (no multiplicative factor change).
-  // °F → K is more complex (offset & scale).
-  degC: tableUnit("degC", dim({ temperature: 1 })),
-  degF: tableUnit("degF", dim({ temperature: 1 })),
-  degR: tableUnit("degR", dim({ temperature: 1 })),
-  // Rankine
-  // --- Plane angle (dimensionless, but often treated as units) --------------
-  rad: tableUnit("rad", dim({}), true),
-  deg: tableUnit("deg", dim({})),
-  grad: tableUnit("grad", dim({})),
-  // --- Force ----------------------------------------------------------------
-  // N = kg·m·s^-2 = 1 kg·m·s^-2; in our base-units representation that's
-  // value=1, dim {length: 1, mass: 1, time: -2}.
-  N: tableUnit("N", dim({ length: 1, mass: 1, time: -2 }), true),
-  dyn: tableUnit("dyn", dim({ length: 1, mass: 1, time: -2 })),
-  lbf: tableUnit("lbf", dim({ length: 1, mass: 1, time: -2 })),
-  // --- Energy ---------------------------------------------------------------
-  J: tableUnit("J", dim({ length: 2, mass: 1, time: -2 }), true),
-  erg: tableUnit("erg", dim({ length: 2, mass: 1, time: -2 })),
-  cal: tableUnit("cal", dim({ length: 2, mass: 1, time: -2 })),
-  eV: tableUnit("eV", dim({ length: 2, mass: 1, time: -2 }), true),
-  BTU: tableUnit("BTU", dim({ length: 2, mass: 1, time: -2 })),
-  // --- Power ----------------------------------------------------------------
-  W: tableUnit("W", dim({ length: 2, mass: 1, time: -3 }), true),
-  hp: tableUnit("hp", dim({ length: 2, mass: 1, time: -3 })),
-  // --- Pressure -------------------------------------------------------------
-  Pa: tableUnit("Pa", dim({ length: -1, mass: 1, time: -2 }), true),
-  bar: tableUnit("bar", dim({ length: -1, mass: 1, time: -2 }), true),
-  atm: tableUnit("atm", dim({ length: -1, mass: 1, time: -2 })),
-  psi: tableUnit("psi", dim({ length: -1, mass: 1, time: -2 })),
-  torr: tableUnit("torr", dim({ length: -1, mass: 1, time: -2 })),
-  mmHg: tableUnit("mmHg", dim({ length: -1, mass: 1, time: -2 })),
-  // --- Electric -------------------------------------------------------------
-  C: tableUnit("C", dim({ time: 1, current: 1 }), true),
-  V: tableUnit("V", dim({ length: 2, mass: 1, time: -3, current: -1 }), true),
-  ohm: tableUnit("ohm", dim({ length: 2, mass: 1, time: -3, current: -2 }), true),
-  \u03A9: tableUnit("ohm", dim({ length: 2, mass: 1, time: -3, current: -2 }), true),
-  F: tableUnit("F", dim({ length: -2, mass: -1, time: 4, current: 2 }), true),
-  H: tableUnit("H", dim({ length: 2, mass: 1, time: -2, current: -2 }), true),
-  // --- Frequency ------------------------------------------------------------
-  Hz: tableUnit("Hz", dim({ time: -1 }), true),
-  // --- Volume ---------------------------------------------------------------
-  L: tableUnit("L", dim({ length: 3 }), true),
-  l: tableUnit("l", dim({ length: 3 }), true),
-  gal: tableUnit("gal", dim({ length: 3 })),
-  // US gallon
-  // --- Area -----------------------------------------------------------------
-  ha: tableUnit("hectare", dim({ length: 2 })),
-  // hectare
-  acre: tableUnit("acre", dim({ length: 2 }))
+const DERIVED_UNITS = {
+	ft: tableUnit("ft", dim({ length: 1 })),
+	foot: tableUnit("foot", dim({ length: 1 })),
+	in: tableUnit("in", dim({ length: 1 })),
+	inch: tableUnit("inch", dim({ length: 1 })),
+	yd: tableUnit("yd", dim({ length: 1 })),
+	yard: tableUnit("yard", dim({ length: 1 })),
+	mi: tableUnit("mi", dim({ length: 1 })),
+	mile: tableUnit("mile", dim({ length: 1 })),
+	g: tableUnit("g", dim({ mass: 1 }), true),
+	lb: tableUnit("lb", dim({ mass: 1 })),
+	lbm: tableUnit("lbm", dim({ mass: 1 })),
+	oz: tableUnit("oz", dim({ mass: 1 })),
+	ton: tableUnit("ton", dim({ mass: 1 })),
+	tonne: tableUnit("tonne", dim({ mass: 1 })),
+	min: tableUnit("min", dim({ time: 1 })),
+	h: tableUnit("h", dim({ time: 1 })),
+	hr: tableUnit("hr", dim({ time: 1 })),
+	day: tableUnit("day", dim({ time: 1 })),
+	week: tableUnit("week", dim({ time: 1 })),
+	year: tableUnit("year", dim({ time: 1 })),
+	degC: tableUnit("degC", dim({ temperature: 1 })),
+	degF: tableUnit("degF", dim({ temperature: 1 })),
+	degR: tableUnit("degR", dim({ temperature: 1 })),
+	rad: tableUnit("rad", dim({}), true),
+	deg: tableUnit("deg", dim({})),
+	grad: tableUnit("grad", dim({})),
+	N: tableUnit("N", dim({
+		length: 1,
+		mass: 1,
+		time: -2
+	}), true),
+	dyn: tableUnit("dyn", dim({
+		length: 1,
+		mass: 1,
+		time: -2
+	})),
+	lbf: tableUnit("lbf", dim({
+		length: 1,
+		mass: 1,
+		time: -2
+	})),
+	J: tableUnit("J", dim({
+		length: 2,
+		mass: 1,
+		time: -2
+	}), true),
+	erg: tableUnit("erg", dim({
+		length: 2,
+		mass: 1,
+		time: -2
+	})),
+	cal: tableUnit("cal", dim({
+		length: 2,
+		mass: 1,
+		time: -2
+	})),
+	eV: tableUnit("eV", dim({
+		length: 2,
+		mass: 1,
+		time: -2
+	}), true),
+	BTU: tableUnit("BTU", dim({
+		length: 2,
+		mass: 1,
+		time: -2
+	})),
+	W: tableUnit("W", dim({
+		length: 2,
+		mass: 1,
+		time: -3
+	}), true),
+	hp: tableUnit("hp", dim({
+		length: 2,
+		mass: 1,
+		time: -3
+	})),
+	Pa: tableUnit("Pa", dim({
+		length: -1,
+		mass: 1,
+		time: -2
+	}), true),
+	bar: tableUnit("bar", dim({
+		length: -1,
+		mass: 1,
+		time: -2
+	}), true),
+	atm: tableUnit("atm", dim({
+		length: -1,
+		mass: 1,
+		time: -2
+	})),
+	psi: tableUnit("psi", dim({
+		length: -1,
+		mass: 1,
+		time: -2
+	})),
+	torr: tableUnit("torr", dim({
+		length: -1,
+		mass: 1,
+		time: -2
+	})),
+	mmHg: tableUnit("mmHg", dim({
+		length: -1,
+		mass: 1,
+		time: -2
+	})),
+	C: tableUnit("C", dim({
+		time: 1,
+		current: 1
+	}), true),
+	V: tableUnit("V", dim({
+		length: 2,
+		mass: 1,
+		time: -3,
+		current: -1
+	}), true),
+	ohm: tableUnit("ohm", dim({
+		length: 2,
+		mass: 1,
+		time: -3,
+		current: -2
+	}), true),
+	Ω: tableUnit("ohm", dim({
+		length: 2,
+		mass: 1,
+		time: -3,
+		current: -2
+	}), true),
+	F: tableUnit("F", dim({
+		length: -2,
+		mass: -1,
+		time: 4,
+		current: 2
+	}), true),
+	H: tableUnit("H", dim({
+		length: 2,
+		mass: 1,
+		time: -2,
+		current: -2
+	}), true),
+	Hz: tableUnit("Hz", dim({ time: -1 }), true),
+	L: tableUnit("L", dim({ length: 3 }), true),
+	l: tableUnit("l", dim({ length: 3 }), true),
+	gal: tableUnit("gal", dim({ length: 3 })),
+	ha: tableUnit("hectare", dim({ length: 2 })),
+	acre: tableUnit("acre", dim({ length: 2 }))
+};
+const ALL_UNITS = {
+	...BASE_UNITS,
+	...DERIVED_UNITS
 };
-var ALL_UNITS = { ...BASE_UNITS, ...DERIVED_UNITS };
-var UNIT_ALIASES = {
-  "\xB0C": "degC",
-  "\xB0F": "degF",
-  "\xB0R": "degR",
-  "\xB0": "deg"
-  // The Unicode micro sign is handled in prefixes; °K is non-standard.
+const UNIT_ALIASES = {
+	"°C": "degC",
+	"°F": "degF",
+	"°R": "degR",
+	"°": "deg"
 };
-function getUnitDef(name2) {
-  return ALL_UNITS[name2];
+function getUnitDef(name) {
+	return ALL_UNITS[name];
 }
-
-// src/types/si-dimension-vector.ts
-var UNIT_DIMENSION_LENGTH = 10;
-var SI_DIMENSION_LENGTH = 7;
-var EXTRA_INDEXES = [7, 8, 9];
+//#endregion
+//#region src/types/si-dimension-vector.ts
+const UNIT_DIMENSION_LENGTH = 10;
+const SI_DIMENSION_LENGTH = 7;
+const EXTRA_INDEXES = [
+	7,
+	8,
+	9
+];
 function assertFinite(label, value) {
-  if (typeof value !== "number" || !Number.isFinite(value)) {
-    throw new TypeError(`${label} must be a finite number`);
-  }
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new TypeError(`${label} must be a finite number`);
+}
+function numberToFractionExponent(value, label = "exponent") {
+	assertFinite(label, value);
+	if (Number.isInteger(value)) return new Fraction(BigInt(value), 1n);
+	return Fraction.fromNumber(value);
+}
+function siExponentToFraction(value, label = "exponent") {
+	if (isFraction(value)) return value;
+	return numberToFractionExponent(value, label);
 }
 function assertUnitVector(vector) {
-  if (vector.length !== UNIT_DIMENSION_LENGTH) {
-    throw new TypeError(`dimension vector must have length ${UNIT_DIMENSION_LENGTH}`);
-  }
-  for (let i = 0; i < vector.length; i++) {
-    assertFinite(`dimension vector[${i}]`, vector[i]);
-  }
+	if (vector.length !== 10) throw new TypeError(`dimension vector must have length 10`);
+	for (let i = 0; i < vector.length; i++) assertFinite(`dimension vector[${i}]`, vector[i]);
 }
 function rejectExtra(vector, options) {
-  if (options?.ignoreExtra) return;
-  for (const index of EXTRA_INDEXES) {
-    if (vector[index] !== 0) {
-      throw new RangeError(
-        `dimension vector has a nonzero angle, bit, or solid-angle exponent at index ${index}; pass { ignoreExtra: true } to drop it`
-      );
-    }
-  }
+	if (options?.ignoreExtra) return;
+	for (const index of EXTRA_INDEXES) if (vector[index] !== 0) throw new RangeError(`dimension vector has a nonzero angle, bit, or solid-angle exponent at index ${index}; pass { ignoreExtra: true } to drop it`);
 }
 function toSiDimensions(vector, options) {
-  assertUnitVector(vector);
-  rejectExtra(vector, options);
-  return {
-    length: vector[1],
-    mass: vector[0],
-    time: vector[2],
-    current: vector[3],
-    temperature: vector[4],
-    amount: vector[6],
-    luminosity: vector[5]
-  };
+	assertUnitVector(vector);
+	rejectExtra(vector, options);
+	return {
+		length: vector[1],
+		mass: vector[0],
+		time: vector[2],
+		current: vector[3],
+		temperature: vector[4],
+		amount: vector[6],
+		luminosity: vector[5]
+	};
 }
 function toSiDimensionVector(vector, options) {
-  const d = toSiDimensions(vector, options);
-  return [d.length, d.mass, d.time, d.current, d.temperature, d.amount, d.luminosity];
+	const d = toSiDimensions(vector, options);
+	return [
+		numberToFractionExponent(d.length),
+		numberToFractionExponent(d.mass),
+		numberToFractionExponent(d.time),
+		numberToFractionExponent(d.current),
+		numberToFractionExponent(d.temperature),
+		numberToFractionExponent(d.amount),
+		numberToFractionExponent(d.luminosity)
+	];
 }
 function fromSiDimensions(dimensions) {
-  const fields = [
-    ["mass", dimensions.mass],
-    ["length", dimensions.length],
-    ["time", dimensions.time],
-    ["current", dimensions.current],
-    ["temperature", dimensions.temperature],
-    ["luminosity", dimensions.luminosity],
-    ["amount", dimensions.amount]
-  ];
-  for (const [name2, value] of fields) {
-    assertFinite(`dimensions.${name2}`, value);
-  }
-  return [
-    dimensions.mass,
-    dimensions.length,
-    dimensions.time,
-    dimensions.current,
-    dimensions.temperature,
-    dimensions.luminosity,
-    dimensions.amount,
-    0,
-    0,
-    0
-  ];
+	const fields = [
+		["mass", dimensions.mass],
+		["length", dimensions.length],
+		["time", dimensions.time],
+		["current", dimensions.current],
+		["temperature", dimensions.temperature],
+		["luminosity", dimensions.luminosity],
+		["amount", dimensions.amount]
+	];
+	for (const [name, value] of fields) assertFinite(`dimensions.${name}`, value);
+	return [
+		dimensions.mass,
+		dimensions.length,
+		dimensions.time,
+		dimensions.current,
+		dimensions.temperature,
+		dimensions.luminosity,
+		dimensions.amount,
+		0,
+		0,
+		0
+	];
 }
 function fromSiDimensionVector(vector) {
-  if (vector.length !== SI_DIMENSION_LENGTH) {
-    throw new TypeError(
-      `SI dimension vector must have length ${SI_DIMENSION_LENGTH} [L, M, T, I, \u0398, N, J]`
-    );
-  }
-  return fromSiDimensions({
-    length: vector[0],
-    mass: vector[1],
-    time: vector[2],
-    current: vector[3],
-    temperature: vector[4],
-    amount: vector[5],
-    luminosity: vector[6]
-  });
+	if (vector.length !== 7) throw new TypeError(`SI dimension vector must have length 7 [L, M, T, I, Θ, N, J]`);
+	const nums = vector.map((component, i) => {
+		const label = `SI dimension vector[${i}]`;
+		const n = siExponentToFraction(component, label).toNumber();
+		assertFinite(label, n);
+		return n;
+	});
+	return fromSiDimensions({
+		length: nums[0],
+		mass: nums[1],
+		time: nums[2],
+		current: nums[3],
+		temperature: nums[4],
+		amount: nums[5],
+		luminosity: nums[6]
+	});
 }
-
-// src/types/unit-prefixes.ts
-var SI_PREFIXES = (() => {
-  const prefixes = {};
-  const short = UNIT_PREFIX_SETS.SHORT;
-  for (const name2 of Object.keys(short)) {
-    if (name2 === "") continue;
-    prefixes[name2] = exactScaleToNumber(unitPrefixExactScale(short[name2]));
-  }
-  prefixes["\xB5"] = prefixes.u;
-  return prefixes;
+//#endregion
+//#region src/types/unit-prefixes.ts
+const SI_PREFIXES = (() => {
+	const prefixes = {};
+	const short = UNIT_PREFIX_SETS.SHORT;
+	for (const name of Object.keys(short)) {
+		if (name === "") continue;
+		prefixes[name] = exactScaleToNumber(unitPrefixExactScale(short[name]));
+	}
+	prefixes["µ"] = prefixes.u;
+	return prefixes;
 })();
-var BEST_PREFIXES = [
-  "Y",
-  "Z",
-  "E",
-  "P",
-  "T",
-  "G",
-  "M",
-  "k",
-  "",
-  "m",
-  "u",
-  "n",
-  "p",
-  "f",
-  "a",
-  "z",
-  "y"
+const BEST_PREFIXES = [
+	"Y",
+	"Z",
+	"E",
+	"P",
+	"T",
+	"G",
+	"M",
+	"k",
+	"",
+	"m",
+	"u",
+	"n",
+	"p",
+	"f",
+	"a",
+	"z",
+	"y"
 ];
-function getPrefix(name2) {
-  return SI_PREFIXES[name2];
+function getPrefix(name) {
+	return SI_PREFIXES[name];
 }
-
-// src/typed/mathts-typed.ts
-import typed, { create } from "typed-function";
-var wasmInitialized = false;
-var wasmAvailable = false;
+//#endregion
+//#region src/typed/mathts-typed.ts
+let wasmInitialized = false;
+let wasmAvailable = false;
 async function initTypedWasm(options = {}) {
-  if (wasmInitialized) return wasmAvailable;
-  try {
-    if (typeof typed.init === "function") {
-      await typed.init({ preferWasm: options.preferWasm ?? true });
-      wasmAvailable = typed.isWasmEnabled?.() ?? false;
-    }
-  } catch {
-    wasmAvailable = false;
-  }
-  wasmInitialized = true;
-  return wasmAvailable;
+	if (wasmInitialized) return wasmAvailable;
+	try {
+		if (typeof typed.init === "function") {
+			await typed.init({ preferWasm: options.preferWasm ?? true });
+			wasmAvailable = typed.isWasmEnabled?.() ?? false;
+		}
+	} catch {
+		wasmAvailable = false;
+	}
+	wasmInitialized = true;
+	return wasmAvailable;
 }
 function isTypedWasmAvailable() {
-  return typed.isWasmEnabled?.() ?? wasmAvailable;
+	return typed.isWasmEnabled?.() ?? wasmAvailable;
 }
-var isNumber = (x) => typeof x === "number";
-var isBoolean = (x) => typeof x === "boolean";
-var isString = (x) => typeof x === "string";
-var isBigInt2 = (x) => typeof x === "bigint";
-var isArray = (x) => Array.isArray(x);
-var isFunction = (x) => typeof x === "function";
-var isObject = (x) => typeof x === "object" && x !== null && !Array.isArray(x);
-var isNull = (x) => x === null;
-var isUndefined = (x) => x === void 0;
-var isFloat64Array = (x) => x instanceof Float64Array;
-var isFloat32Array = (x) => x instanceof Float32Array;
-var isInt32Array = (x) => x instanceof Int32Array;
-var isUint32Array = (x) => x instanceof Uint32Array;
-var isUint8Array = (x) => x instanceof Uint8Array;
-var isComplex2 = (x) => isComplex(x);
-var isFraction2 = (x) => isFraction(x);
-var isBigNumber3 = (x) => isBigNumber2(x);
-var isMatrix = (x) => isObject(x) && "rows" in x && "cols" in x && "get" in x && typeof x.type === "string";
-var isDenseMatrix = (x) => isMatrix(x) && x.type === "DenseMatrix";
-var isSparseMatrix = (x) => isMatrix(x) && x.type === "SparseMatrix";
-var isUnit2 = (x) => {
-  if (!isObject(x)) return false;
-  const o = x;
-  if (typeof o.type !== "string") return false;
-  if (o.type === "Unit" && "value" in o && "dimensions" in o) return true;
-  if ("value" in o && "unit" in o) return true;
-  return false;
+const isNumber = (x) => typeof x === "number";
+const isBoolean = (x) => typeof x === "boolean";
+const isString = (x) => typeof x === "string";
+const isBigInt = (x) => typeof x === "bigint";
+const isArray = (x) => Array.isArray(x);
+const isFunction = (x) => typeof x === "function";
+const isObject = (x) => typeof x === "object" && x !== null && !Array.isArray(x);
+const isNull = (x) => x === null;
+const isUndefined = (x) => x === void 0;
+const isFloat64Array = (x) => x instanceof Float64Array;
+const isFloat32Array = (x) => x instanceof Float32Array;
+const isInt32Array = (x) => x instanceof Int32Array;
+const isUint32Array = (x) => x instanceof Uint32Array;
+const isUint8Array = (x) => x instanceof Uint8Array;
+const isComplex$1 = (x) => isComplex(x);
+const isFraction$1 = (x) => isFraction(x);
+const isBigNumber$1 = (x) => isBigNumber(x);
+const isMatrix = (x) => isObject(x) && "rows" in x && "cols" in x && "get" in x && typeof x.type === "string";
+const isDenseMatrix = (x) => isMatrix(x) && x.type === "DenseMatrix";
+const isSparseMatrix = (x) => isMatrix(x) && x.type === "SparseMatrix";
+const isUnit = (x) => {
+	if (!isObject(x)) return false;
+	const o = x;
+	if (typeof o.type !== "string") return false;
+	if (o.type === "Unit" && "value" in o && "dimensions" in o) return true;
+	if ("value" in o && "unit" in o) return true;
+	return false;
 };
-var MATHTS_TYPES = [
-  // bigint is not built into typed-function
-  { name: "bigint", test: isBigInt2 },
-  // MathTS numeric types (ordered by specificity for conversion priority)
-  // WASM masks use typed.masks.OBJECT | typed.masks.custom(N) pattern
-  { name: "Complex", test: isComplex2 },
-  { name: "Fraction", test: isFraction2 },
-  { name: "BigNumber", test: isBigNumber3 },
-  // TypedArrays (for parallel-first WASM operations)
-  { name: "Float64Array", test: isFloat64Array },
-  { name: "Float32Array", test: isFloat32Array },
-  { name: "Int32Array", test: isInt32Array },
-  { name: "Uint32Array", test: isUint32Array },
-  { name: "Uint8Array", test: isUint8Array },
-  // Matrix types
-  { name: "DenseMatrix", test: isDenseMatrix },
-  { name: "SparseMatrix", test: isSparseMatrix },
-  { name: "Matrix", test: isMatrix },
-  // Other types
-  { name: "Unit", test: isUnit2 },
-  { name: "Dual", test: isDual }
+const MATHTS_TYPES = [
+	{
+		name: "bigint",
+		test: isBigInt
+	},
+	{
+		name: "Complex",
+		test: isComplex$1
+	},
+	{
+		name: "Fraction",
+		test: isFraction$1
+	},
+	{
+		name: "BigNumber",
+		test: isBigNumber$1
+	},
+	{
+		name: "Float64Array",
+		test: isFloat64Array
+	},
+	{
+		name: "Float32Array",
+		test: isFloat32Array
+	},
+	{
+		name: "Int32Array",
+		test: isInt32Array
+	},
+	{
+		name: "Uint32Array",
+		test: isUint32Array
+	},
+	{
+		name: "Uint8Array",
+		test: isUint8Array
+	},
+	{
+		name: "DenseMatrix",
+		test: isDenseMatrix
+	},
+	{
+		name: "SparseMatrix",
+		test: isSparseMatrix
+	},
+	{
+		name: "Matrix",
+		test: isMatrix
+	},
+	{
+		name: "Unit",
+		test: isUnit
+	},
+	{
+		name: "Dual",
+		test: isDual
+	}
 ];
-var MATHTS_CONVERSIONS = [
-  // -------------------------------------------------------------------------
-  // To Complex conversions
-  // -------------------------------------------------------------------------
-  {
-    from: "number",
-    to: "Complex",
-    convert: (n) => Complex.fromNumber(n)
-  },
-  {
-    from: "Fraction",
-    to: "Complex",
-    convert: (f) => Complex.fromNumber(f.toNumber())
-  },
-  {
-    from: "BigNumber",
-    to: "Complex",
-    convert: (bn) => Complex.fromNumber(bn.valueOf())
-  },
-  {
-    from: "string",
-    to: "Complex",
-    convert: (s) => Complex.parse(s)
-  },
-  // -------------------------------------------------------------------------
-  // To Fraction conversions
-  // -------------------------------------------------------------------------
-  {
-    from: "number",
-    to: "Fraction",
-    convert: (n) => Fraction.fromNumber(n)
-  },
-  {
-    from: "bigint",
-    to: "Fraction",
-    convert: (n) => new Fraction(n, 1n)
-  },
-  {
-    from: "string",
-    to: "Fraction",
-    convert: (s) => Fraction.parse(s)
-  },
-  // -------------------------------------------------------------------------
-  // To BigNumber conversions
-  // -------------------------------------------------------------------------
-  {
-    from: "number",
-    to: "BigNumber",
-    convert: (n) => BigNumber.fromNumber(n)
-  },
-  {
-    from: "bigint",
-    to: "BigNumber",
-    convert: (n) => BigNumber.fromBigInt(n)
-  },
-  {
-    from: "Fraction",
-    to: "BigNumber",
-    convert: (f) => BigNumber.fromNumber(f.toNumber())
-  },
-  {
-    from: "string",
-    to: "BigNumber",
-    convert: (s) => BigNumber.parse(s)
-  },
-  // -------------------------------------------------------------------------
-  // To number conversions
-  // -------------------------------------------------------------------------
-  {
-    from: "boolean",
-    to: "number",
-    convert: (b) => b ? 1 : 0
-  },
-  {
-    from: "string",
-    to: "number",
-    convert: (s) => {
-      const n = parseFloat(s);
-      if (isNaN(n)) throw new Error(`Cannot convert "${s}" to number`);
-      return n;
-    }
-  },
-  {
-    from: "bigint",
-    to: "number",
-    convert: (n) => Number(n)
-  },
-  {
-    from: "Fraction",
-    to: "number",
-    convert: (f) => f.toNumber()
-  },
-  {
-    from: "BigNumber",
-    to: "number",
-    convert: (bn) => bn.valueOf()
-  },
-  // -------------------------------------------------------------------------
-  // To bigint conversions
-  // -------------------------------------------------------------------------
-  {
-    from: "number",
-    to: "bigint",
-    convert: (n) => BigInt(Math.trunc(n))
-  },
-  {
-    from: "Fraction",
-    to: "bigint",
-    convert: (f) => f.trunc().numerator
-  },
-  {
-    from: "BigNumber",
-    to: "bigint",
-    convert: (bn) => bn.toBigInt()
-  },
-  {
-    from: "string",
-    to: "bigint",
-    convert: (s) => BigInt(s)
-  },
-  // -------------------------------------------------------------------------
-  // Matrix conversions (placeholder until Matrix is implemented)
-  // -------------------------------------------------------------------------
-  {
-    from: "Array",
-    to: "Matrix",
-    convert: (a) => {
-      const arr = a;
-      return {
-        rows: arr.length,
-        cols: arr[0]?.length ?? 0,
-        data: arr.flat(),
-        type: "DenseMatrix",
-        get: (r, c) => arr[r]?.[c]
-      };
-    }
-  },
-  {
-    from: "Matrix",
-    to: "Array",
-    convert: (m) => {
-      const matrix = m;
-      const result = [];
-      for (let i = 0; i < matrix.rows; i++) {
-        result[i] = [];
-        for (let j = 0; j < matrix.cols; j++) {
-          result[i][j] = matrix.get(i, j);
-        }
-      }
-      return result;
-    }
-  },
-  {
-    from: "DenseMatrix",
-    to: "SparseMatrix",
-    convert: (m) => {
-      return { ...m, type: "SparseMatrix" };
-    }
-  }
+const MATHTS_CONVERSIONS = [
+	{
+		from: "number",
+		to: "Complex",
+		convert: (n) => Complex.fromNumber(n)
+	},
+	{
+		from: "Fraction",
+		to: "Complex",
+		convert: (f) => Complex.fromNumber(f.toNumber())
+	},
+	{
+		from: "BigNumber",
+		to: "Complex",
+		convert: (bn) => Complex.fromNumber(bn.valueOf())
+	},
+	{
+		from: "string",
+		to: "Complex",
+		convert: (s) => Complex.parse(s)
+	},
+	{
+		from: "number",
+		to: "Fraction",
+		convert: (n) => Fraction.fromNumber(n)
+	},
+	{
+		from: "bigint",
+		to: "Fraction",
+		convert: (n) => new Fraction(n, 1n)
+	},
+	{
+		from: "string",
+		to: "Fraction",
+		convert: (s) => Fraction.parse(s)
+	},
+	{
+		from: "number",
+		to: "BigNumber",
+		convert: (n) => BigNumber.fromNumber(n)
+	},
+	{
+		from: "bigint",
+		to: "BigNumber",
+		convert: (n) => BigNumber.fromBigInt(n)
+	},
+	{
+		from: "Fraction",
+		to: "BigNumber",
+		convert: (f) => BigNumber.fromNumber(f.toNumber())
+	},
+	{
+		from: "string",
+		to: "BigNumber",
+		convert: (s) => BigNumber.parse(s)
+	},
+	{
+		from: "boolean",
+		to: "number",
+		convert: (b) => b ? 1 : 0
+	},
+	{
+		from: "string",
+		to: "number",
+		convert: (s) => {
+			const n = parseFloat(s);
+			if (isNaN(n)) throw new Error(`Cannot convert "${s}" to number`);
+			return n;
+		}
+	},
+	{
+		from: "bigint",
+		to: "number",
+		convert: (n) => Number(n)
+	},
+	{
+		from: "Fraction",
+		to: "number",
+		convert: (f) => f.toNumber()
+	},
+	{
+		from: "BigNumber",
+		to: "number",
+		convert: (bn) => bn.valueOf()
+	},
+	{
+		from: "number",
+		to: "bigint",
+		convert: (n) => BigInt(Math.trunc(n))
+	},
+	{
+		from: "Fraction",
+		to: "bigint",
+		convert: (f) => f.trunc().numerator
+	},
+	{
+		from: "BigNumber",
+		to: "bigint",
+		convert: (bn) => bn.toBigInt()
+	},
+	{
+		from: "string",
+		to: "bigint",
+		convert: (s) => BigInt(s)
+	},
+	{
+		from: "Array",
+		to: "Matrix",
+		convert: (a) => {
+			const arr = a;
+			return {
+				rows: arr.length,
+				cols: arr[0]?.length ?? 0,
+				data: arr.flat(),
+				type: "DenseMatrix",
+				get: (r, c) => arr[r]?.[c]
+			};
+		}
+	},
+	{
+		from: "Matrix",
+		to: "Array",
+		convert: (m) => {
+			const matrix = m;
+			const result = [];
+			for (let i = 0; i < matrix.rows; i++) {
+				result[i] = [];
+				for (let j = 0; j < matrix.cols; j++) result[i][j] = matrix.get(i, j);
+			}
+			return result;
+		}
+	},
+	{
+		from: "DenseMatrix",
+		to: "SparseMatrix",
+		convert: (m) => {
+			return {
+				...m,
+				type: "SparseMatrix"
+			};
+		}
+	}
 ];
 function createMathTSTyped() {
-  const instance = create();
-  if (typeof instance.addType === "function") {
-    for (const typeDef of MATHTS_TYPES) {
-      instance.addType(typeDef);
-    }
-  } else {
-    instance.addTypes(MATHTS_TYPES, "any");
-  }
-  instance.addConversions(MATHTS_CONVERSIONS);
-  return instance;
+	const instance = create();
+	if (typeof instance.addType === "function") for (const typeDef of MATHTS_TYPES) instance.addType(typeDef);
+	else instance.addTypes(MATHTS_TYPES, "any");
+	instance.addConversions(MATHTS_CONVERSIONS);
+	return instance;
 }
-var mathTyped = createMathTSTyped();
+const mathTyped = createMathTSTyped();
 var TypeRegistry = class {
-  types = /* @__PURE__ */ new Map();
-  conversions = /* @__PURE__ */ new Map();
-  instance = null;
-  /**
-   * Register a new type
-   */
-  registerType(name2, test) {
-    this.types.set(name2, { name: name2, test });
-    this.instance = null;
-    return this;
-  }
-  /**
-   * Register a type conversion
-   */
-  registerConversion(from, to, convert) {
-    const key = `${from}->${to}`;
-    this.conversions.set(key, {
-      from,
-      to,
-      convert
-    });
-    this.instance = null;
-    return this;
-  }
-  /**
-   * Check if a type is registered
-   */
-  hasType(name2) {
-    return this.types.has(name2);
-  }
-  /**
-   * Check if a conversion is registered
-   */
-  hasConversion(from, to) {
-    return this.conversions.has(`${from}->${to}`);
-  }
-  /**
-   * Get all registered type names
-   */
-  getTypeNames() {
-    return Array.from(this.types.keys());
-  }
-  /**
-   * Build a typed-function instance from the registry
-   */
-  build() {
-    if (!this.instance) {
-      const inst = create();
-      inst.addTypes(Array.from(this.types.values()), "any");
-      inst.addConversions(Array.from(this.conversions.values()));
-      this.instance = inst;
-    }
-    return this.instance;
-  }
-  /**
-   * Clear all registered types and conversions
-   */
-  clear() {
-    this.types.clear();
-    this.conversions.clear();
-    this.instance = null;
-  }
+	types = /* @__PURE__ */ new Map();
+	conversions = /* @__PURE__ */ new Map();
+	instance = null;
+	registerType(name, test) {
+		this.types.set(name, {
+			name,
+			test
+		});
+		this.instance = null;
+		return this;
+	}
+	registerConversion(from, to, convert) {
+		const key = `${from}->${to}`;
+		this.conversions.set(key, {
+			from,
+			to,
+			convert
+		});
+		this.instance = null;
+		return this;
+	}
+	hasType(name) {
+		return this.types.has(name);
+	}
+	hasConversion(from, to) {
+		return this.conversions.has(`${from}->${to}`);
+	}
+	getTypeNames() {
+		return Array.from(this.types.keys());
+	}
+	build() {
+		if (!this.instance) {
+			const inst = create();
+			inst.addTypes(Array.from(this.types.values()), "any");
+			inst.addConversions(Array.from(this.conversions.values()));
+			this.instance = inst;
+		}
+		return this.instance;
+	}
+	clear() {
+		this.types.clear();
+		this.conversions.clear();
+		this.instance = null;
+	}
 };
-function createTypedFunction(name2, signatures, typedInstance = mathTyped) {
-  return typedInstance(name2, signatures);
+function createTypedFunction(name, signatures, typedInstance = mathTyped) {
+	return typedInstance(name, signatures);
 }
-
-// src/typed/type-bridge.ts
-var registered = false;
+//#endregion
+//#region src/typed/type-bridge.ts
+let registered = false;
 function registerNativeTypes() {
-  if (registered) return;
-  registered = true;
-  if (!("isComplex" in Complex.prototype)) {
-    Object.defineProperty(Complex.prototype, "isComplex", {
-      value: true,
-      writable: false,
-      enumerable: false,
-      configurable: false
-    });
-  }
-  if (!("type" in Complex.prototype)) {
-    Object.defineProperty(Complex.prototype, "type", {
-      value: "Complex",
-      writable: false,
-      enumerable: false,
-      configurable: false
-    });
-  }
-  if (!("isFraction" in Fraction.prototype)) {
-    Object.defineProperty(Fraction.prototype, "isFraction", {
-      value: true,
-      writable: false,
-      enumerable: false,
-      configurable: false
-    });
-  }
-  if (!("type" in Fraction.prototype)) {
-    Object.defineProperty(Fraction.prototype, "type", {
-      value: "Fraction",
-      writable: false,
-      enumerable: false,
-      configurable: false
-    });
-  }
-  if (!("isBigNumber" in BigNumber.prototype)) {
-    Object.defineProperty(BigNumber.prototype, "isBigNumber", {
-      value: true,
-      writable: false,
-      enumerable: false,
-      configurable: false
-    });
-  }
-  if (!("type" in BigNumber.prototype)) {
-    Object.defineProperty(BigNumber.prototype, "type", {
-      value: "BigNumber",
-      writable: false,
-      enumerable: false,
-      configurable: false
-    });
-  }
+	if (registered) return;
+	registered = true;
+	if (!("isComplex" in Complex.prototype)) Object.defineProperty(Complex.prototype, "isComplex", {
+		value: true,
+		writable: false,
+		enumerable: false,
+		configurable: false
+	});
+	if (!("type" in Complex.prototype)) Object.defineProperty(Complex.prototype, "type", {
+		value: "Complex",
+		writable: false,
+		enumerable: false,
+		configurable: false
+	});
+	if (!("isFraction" in Fraction.prototype)) Object.defineProperty(Fraction.prototype, "isFraction", {
+		value: true,
+		writable: false,
+		enumerable: false,
+		configurable: false
+	});
+	if (!("type" in Fraction.prototype)) Object.defineProperty(Fraction.prototype, "type", {
+		value: "Fraction",
+		writable: false,
+		enumerable: false,
+		configurable: false
+	});
+	if (!("isBigNumber" in BigNumber.prototype)) Object.defineProperty(BigNumber.prototype, "isBigNumber", {
+		value: true,
+		writable: false,
+		enumerable: false,
+		configurable: false
+	});
+	if (!("type" in BigNumber.prototype)) Object.defineProperty(BigNumber.prototype, "type", {
+		value: "BigNumber",
+		writable: false,
+		enumerable: false,
+		configurable: false
+	});
 }
-
-// src/factory/factory.ts
-var DEFAULT_CONFIG = {
-  precision: 64,
-  matrix: "Matrix",
-  number: "number",
-  randomSeed: null,
-  epsilon: 1e-12,
-  preferredBackend: "auto",
-  wasmThreshold: 1e3,
-  gpuThreshold: 1e5,
-  parallelEnabled: true,
-  parallelThreshold: 5e4
+//#endregion
+//#region src/factory/factory.ts
+const DEFAULT_CONFIG = {
+	precision: 64,
+	matrix: "Matrix",
+	number: "number",
+	randomSeed: null,
+	epsilon: 1e-12,
+	preferredBackend: "auto",
+	wasmThreshold: 1e3,
+	gpuThreshold: 1e5,
+	parallelEnabled: true,
+	parallelThreshold: 5e4
 };
 var FunctionRegistry = class {
-  factories = /* @__PURE__ */ new Map();
-  instances = /* @__PURE__ */ new Map();
-  dependencies;
-  creating = /* @__PURE__ */ new Set();
-  constructor(config = {}, typed2 = mathTyped) {
-    this.dependencies = {
-      config: { ...DEFAULT_CONFIG, ...config },
-      typed: typed2
-    };
-  }
-  /**
-   * Register a factory function
-   */
-  register(factory2) {
-    this.factories.set(factory2.name, factory2);
-  }
-  /**
-   * Register multiple factory functions
-   */
-  registerAll(factories) {
-    for (const factory2 of factories) {
-      this.register(factory2);
-    }
-  }
-  /**
-   * Get or create a function by name
-   */
-  get(name2) {
-    const existing = this.instances.get(name2);
-    if (existing) return existing;
-    if (this.creating.has(name2)) {
-      throw new Error(`Circular dependency detected: ${name2}`);
-    }
-    const factory2 = this.factories.get(name2);
-    if (!factory2) {
-      throw new Error(`Unknown function: ${name2}`);
-    }
-    this.creating.add(name2);
-    try {
-      const deps = { ...this.dependencies };
-      for (const depName of factory2.dependencies) {
-        if (depName === "config" || depName === "typed") continue;
-        deps[depName] = this.get(depName);
-      }
-      const fn = factory2.factory(deps);
-      this.instances.set(name2, fn);
-      this.dependencies[name2] = fn;
-      return fn;
-    } finally {
-      this.creating.delete(name2);
-    }
-  }
-  /**
-   * Check if a function is registered
-   */
-  has(name2) {
-    return this.factories.has(name2);
-  }
-  /**
-   * Get all registered function names
-   */
-  names() {
-    return Array.from(this.factories.keys());
-  }
-  /**
-   * Update configuration
-   */
-  updateConfig(config) {
-    this.dependencies.config = { ...this.dependencies.config, ...config };
-    this.instances.clear();
-  }
-  /**
-   * Get current configuration
-   */
-  getConfig() {
-    return { ...this.dependencies.config };
-  }
+	factories = /* @__PURE__ */ new Map();
+	instances = /* @__PURE__ */ new Map();
+	dependencies;
+	creating = /* @__PURE__ */ new Set();
+	constructor(config = {}, typed = mathTyped) {
+		this.dependencies = {
+			config: {
+				...DEFAULT_CONFIG,
+				...config
+			},
+			typed
+		};
+	}
+	register(factory) {
+		this.factories.set(factory.name, factory);
+	}
+	registerAll(factories) {
+		for (const factory of factories) this.register(factory);
+	}
+	get(name) {
+		const existing = this.instances.get(name);
+		if (existing) return existing;
+		if (this.creating.has(name)) throw new Error(`Circular dependency detected: ${name}`);
+		const factory = this.factories.get(name);
+		if (!factory) throw new Error(`Unknown function: ${name}`);
+		this.creating.add(name);
+		try {
+			const deps = { ...this.dependencies };
+			for (const depName of factory.dependencies) {
+				if (depName === "config" || depName === "typed") continue;
+				deps[depName] = this.get(depName);
+			}
+			const fn = factory.factory(deps);
+			this.instances.set(name, fn);
+			this.dependencies[name] = fn;
+			return fn;
+		} finally {
+			this.creating.delete(name);
+		}
+	}
+	has(name) {
+		return this.factories.has(name);
+	}
+	names() {
+		return Array.from(this.factories.keys());
+	}
+	updateConfig(config) {
+		this.dependencies.config = {
+			...this.dependencies.config,
+			...config
+		};
+		this.instances.clear();
+	}
+	getConfig() {
+		return { ...this.dependencies.config };
+	}
 };
-function createFactory(name2, dependencies2, factory2) {
-  return { name: name2, dependencies: dependencies2, factory: factory2 };
+function createFactory(name, dependencies, factory) {
+	return {
+		name,
+		dependencies,
+		factory
+	};
 }
-var registry = new FunctionRegistry();
-var math = {
-  /**
-   * Get a registered function
-   */
-  get: (name2) => registry.get(name2),
-  /**
-   * Register a factory function
-   */
-  register: (factory2) => registry.register(factory2),
-  /**
-   * Get configuration
-   */
-  config: () => registry.getConfig(),
-  /**
-   * Update configuration
-   */
-  configure: (config) => registry.updateConfig(config)
+const registry = new FunctionRegistry();
+const math = {
+	get: (name) => registry.get(name),
+	register: (factory) => registry.register(factory),
+	config: () => registry.getConfig(),
+	configure: (config) => registry.updateConfig(config)
 };
-
-// src/numeric/stable.ts
-var PAIRWISE_BLOCK = 128;
+//#endregion
+//#region src/numeric/stable.ts
+const PAIRWISE_BLOCK = 128;
 function pairwiseSum(xs, start = 0, end = xs.length) {
-  const n = end - start;
-  if (n <= PAIRWISE_BLOCK) {
-    let s0 = 0;
-    let s1 = 0;
-    let s2 = 0;
-    let s3 = 0;
-    let s4 = 0;
-    let s5 = 0;
-    let s6 = 0;
-    let s7 = 0;
-    let i = start;
-    const limit = start + (n - n % 8);
-    for (; i < limit; i += 8) {
-      s0 += xs[i];
-      s1 += xs[i + 1];
-      s2 += xs[i + 2];
-      s3 += xs[i + 3];
-      s4 += xs[i + 4];
-      s5 += xs[i + 5];
-      s6 += xs[i + 6];
-      s7 += xs[i + 7];
-    }
-    let tail = 0;
-    for (; i < end; i++) tail += xs[i];
-    return s0 + s1 + (s2 + s3) + (s4 + s5 + (s6 + s7)) + tail;
-  }
-  const half = (n >> 1) - (n >> 1) % 8;
-  return pairwiseSum(xs, start, start + half) + pairwiseSum(xs, start + half, end);
+	const n = end - start;
+	if (n <= PAIRWISE_BLOCK) {
+		let s0 = 0;
+		let s1 = 0;
+		let s2 = 0;
+		let s3 = 0;
+		let s4 = 0;
+		let s5 = 0;
+		let s6 = 0;
+		let s7 = 0;
+		let i = start;
+		const limit = start + (n - n % 8);
+		for (; i < limit; i += 8) {
+			s0 += xs[i];
+			s1 += xs[i + 1];
+			s2 += xs[i + 2];
+			s3 += xs[i + 3];
+			s4 += xs[i + 4];
+			s5 += xs[i + 5];
+			s6 += xs[i + 6];
+			s7 += xs[i + 7];
+		}
+		let tail = 0;
+		for (; i < end; i++) tail += xs[i];
+		return s0 + s1 + (s2 + s3) + (s4 + s5 + (s6 + s7)) + tail;
+	}
+	const half = (n >> 1) - (n >> 1) % 8;
+	return pairwiseSum(xs, start, start + half) + pairwiseSum(xs, start + half, end);
 }
 function neumaierSum(xs) {
-  let sum = 0;
-  let c = 0;
-  for (let i = 0; i < xs.length; i++) {
-    const x = xs[i];
-    const t = sum + x;
-    c += Math.abs(sum) >= Math.abs(x) ? sum - t + x : x - t + sum;
-    sum = t;
-  }
-  return sum + c;
+	let sum = 0;
+	let c = 0;
+	for (let i = 0; i < xs.length; i++) {
+		const x = xs[i];
+		const t = sum + x;
+		c += Math.abs(sum) >= Math.abs(x) ? sum - t + x : x - t + sum;
+		sum = t;
+	}
+	return sum + c;
 }
 function norm2(xs) {
-  let scale = 0;
-  let ssq = 1;
-  for (let i = 0; i < xs.length; i++) {
-    const x = xs[i];
-    if (x === 0) continue;
-    if (Number.isNaN(x)) return NaN;
-    const ax = Math.abs(x);
-    if (scale < ax) {
-      const r = scale / ax;
-      ssq = 1 + ssq * r * r;
-      scale = ax;
-    } else {
-      const r = ax / scale;
-      ssq += r * r;
-    }
-  }
-  return scale === 0 ? 0 : scale * Math.sqrt(ssq);
+	let scale = 0;
+	let ssq = 1;
+	for (let i = 0; i < xs.length; i++) {
+		const x = xs[i];
+		if (x === 0) continue;
+		if (Number.isNaN(x)) return NaN;
+		const ax = Math.abs(x);
+		if (scale < ax) {
+			const r = scale / ax;
+			ssq = 1 + ssq * r * r;
+			scale = ax;
+		} else {
+			const r = ax / scale;
+			ssq += r * r;
+		}
+	}
+	return scale === 0 ? 0 : scale * Math.sqrt(ssq);
 }
 function pairwiseDot(a, b, start = 0, end = a.length) {
-  const n = end - start;
-  if (n <= PAIRWISE_BLOCK) {
-    let s0 = 0;
-    let s1 = 0;
-    let s2 = 0;
-    let s3 = 0;
-    let s4 = 0;
-    let s5 = 0;
-    let s6 = 0;
-    let s7 = 0;
-    let i = start;
-    const limit = start + (n - n % 8);
-    for (; i < limit; i += 8) {
-      s0 += a[i] * b[i];
-      s1 += a[i + 1] * b[i + 1];
-      s2 += a[i + 2] * b[i + 2];
-      s3 += a[i + 3] * b[i + 3];
-      s4 += a[i + 4] * b[i + 4];
-      s5 += a[i + 5] * b[i + 5];
-      s6 += a[i + 6] * b[i + 6];
-      s7 += a[i + 7] * b[i + 7];
-    }
-    let tail = 0;
-    for (; i < end; i++) tail += a[i] * b[i];
-    return s0 + s1 + (s2 + s3) + (s4 + s5 + (s6 + s7)) + tail;
-  }
-  const half = (n >> 1) - (n >> 1) % 8;
-  return pairwiseDot(a, b, start, start + half) + pairwiseDot(a, b, start + half, end);
+	const n = end - start;
+	if (n <= PAIRWISE_BLOCK) {
+		let s0 = 0;
+		let s1 = 0;
+		let s2 = 0;
+		let s3 = 0;
+		let s4 = 0;
+		let s5 = 0;
+		let s6 = 0;
+		let s7 = 0;
+		let i = start;
+		const limit = start + (n - n % 8);
+		for (; i < limit; i += 8) {
+			s0 += a[i] * b[i];
+			s1 += a[i + 1] * b[i + 1];
+			s2 += a[i + 2] * b[i + 2];
+			s3 += a[i + 3] * b[i + 3];
+			s4 += a[i + 4] * b[i + 4];
+			s5 += a[i + 5] * b[i + 5];
+			s6 += a[i + 6] * b[i + 6];
+			s7 += a[i + 7] * b[i + 7];
+		}
+		let tail = 0;
+		for (; i < end; i++) tail += a[i] * b[i];
+		return s0 + s1 + (s2 + s3) + (s4 + s5 + (s6 + s7)) + tail;
+	}
+	const half = (n >> 1) - (n >> 1) % 8;
+	return pairwiseDot(a, b, start, start + half) + pairwiseDot(a, b, start + half, end);
 }
 function scaledDistance(a, b) {
-  let scale = 0;
-  let ssq = 1;
-  for (let i = 0; i < a.length; i++) {
-    const d = a[i] - b[i];
-    if (d === 0) continue;
-    if (Number.isNaN(d)) return NaN;
-    const ad = Math.abs(d);
-    if (scale < ad) {
-      const r = scale / ad;
-      ssq = 1 + ssq * r * r;
-      scale = ad;
-    } else {
-      const r = ad / scale;
-      ssq += r * r;
-    }
-  }
-  return scale === 0 ? 0 : scale * Math.sqrt(ssq);
+	let scale = 0;
+	let ssq = 1;
+	for (let i = 0; i < a.length; i++) {
+		const d = a[i] - b[i];
+		if (d === 0) continue;
+		if (Number.isNaN(d)) return NaN;
+		const ad = Math.abs(d);
+		if (scale < ad) {
+			const r = scale / ad;
+			ssq = 1 + ssq * r * r;
+			scale = ad;
+		} else {
+			const r = ad / scale;
+			ssq += r * r;
+		}
+	}
+	return scale === 0 ? 0 : scale * Math.sqrt(ssq);
 }
 function sumSquaredDeviations(xs) {
-  const n = xs.length;
-  if (n < 2) return 0;
-  const mean = pairwiseSum(xs) / n;
-  const { sumD, sumDD } = pairwiseDeviationSums(xs, mean, 0, n);
-  const corrected = sumDD - sumD * sumD / n;
-  return corrected < 0 ? 0 : corrected;
+	const n = xs.length;
+	if (n < 2) return 0;
+	const { sumD, sumDD } = pairwiseDeviationSums(xs, pairwiseSum(xs) / n, 0, n);
+	const corrected = sumDD - sumD * sumD / n;
+	return corrected < 0 ? 0 : corrected;
 }
 function pairwiseDeviationSums(xs, mean, start, end) {
-  const n = end - start;
-  if (n <= PAIRWISE_BLOCK) {
-    let d0 = 0, d1 = 0, d2 = 0, d3 = 0, d4 = 0, d5 = 0, d6 = 0, d7 = 0;
-    let q0 = 0, q1 = 0, q2 = 0, q3 = 0, q4 = 0, q5 = 0, q6 = 0, q7 = 0;
-    let i = start;
-    const limit = start + (n - n % 8);
-    for (; i < limit; i += 8) {
-      const a0 = xs[i] - mean;
-      const a1 = xs[i + 1] - mean;
-      const a2 = xs[i + 2] - mean;
-      const a3 = xs[i + 3] - mean;
-      const a4 = xs[i + 4] - mean;
-      const a5 = xs[i + 5] - mean;
-      const a6 = xs[i + 6] - mean;
-      const a7 = xs[i + 7] - mean;
-      d0 += a0;
-      q0 += a0 * a0;
-      d1 += a1;
-      q1 += a1 * a1;
-      d2 += a2;
-      q2 += a2 * a2;
-      d3 += a3;
-      q3 += a3 * a3;
-      d4 += a4;
-      q4 += a4 * a4;
-      d5 += a5;
-      q5 += a5 * a5;
-      d6 += a6;
-      q6 += a6 * a6;
-      d7 += a7;
-      q7 += a7 * a7;
-    }
-    let tailD = 0;
-    let tailDD = 0;
-    for (; i < end; i++) {
-      const a = xs[i] - mean;
-      tailD += a;
-      tailDD += a * a;
-    }
-    return {
-      sumD: d0 + d1 + (d2 + d3) + (d4 + d5 + (d6 + d7)) + tailD,
-      sumDD: q0 + q1 + (q2 + q3) + (q4 + q5 + (q6 + q7)) + tailDD
-    };
-  }
-  const half = (n >> 1) - (n >> 1) % 8;
-  const left = pairwiseDeviationSums(xs, mean, start, start + half);
-  const right = pairwiseDeviationSums(xs, mean, start + half, end);
-  return { sumD: left.sumD + right.sumD, sumDD: left.sumDD + right.sumDD };
+	const n = end - start;
+	if (n <= PAIRWISE_BLOCK) {
+		let d0 = 0, d1 = 0, d2 = 0, d3 = 0, d4 = 0, d5 = 0, d6 = 0, d7 = 0;
+		let q0 = 0, q1 = 0, q2 = 0, q3 = 0, q4 = 0, q5 = 0, q6 = 0, q7 = 0;
+		let i = start;
+		const limit = start + (n - n % 8);
+		for (; i < limit; i += 8) {
+			const a0 = xs[i] - mean;
+			const a1 = xs[i + 1] - mean;
+			const a2 = xs[i + 2] - mean;
+			const a3 = xs[i + 3] - mean;
+			const a4 = xs[i + 4] - mean;
+			const a5 = xs[i + 5] - mean;
+			const a6 = xs[i + 6] - mean;
+			const a7 = xs[i + 7] - mean;
+			d0 += a0;
+			q0 += a0 * a0;
+			d1 += a1;
+			q1 += a1 * a1;
+			d2 += a2;
+			q2 += a2 * a2;
+			d3 += a3;
+			q3 += a3 * a3;
+			d4 += a4;
+			q4 += a4 * a4;
+			d5 += a5;
+			q5 += a5 * a5;
+			d6 += a6;
+			q6 += a6 * a6;
+			d7 += a7;
+			q7 += a7 * a7;
+		}
+		let tailD = 0;
+		let tailDD = 0;
+		for (; i < end; i++) {
+			const a = xs[i] - mean;
+			tailD += a;
+			tailDD += a * a;
+		}
+		return {
+			sumD: d0 + d1 + (d2 + d3) + (d4 + d5 + (d6 + d7)) + tailD,
+			sumDD: q0 + q1 + (q2 + q3) + (q4 + q5 + (q6 + q7)) + tailDD
+		};
+	}
+	const half = (n >> 1) - (n >> 1) % 8;
+	const left = pairwiseDeviationSums(xs, mean, start, start + half);
+	const right = pairwiseDeviationSums(xs, mean, start + half, end);
+	return {
+		sumD: left.sumD + right.sumD,
+		sumDD: left.sumDD + right.sumDD
+	};
 }
 function neumaierCumsum(xs, out) {
-  let sum = 0;
-  let c = 0;
-  for (let i = 0; i < xs.length; i++) {
-    const x = xs[i];
-    const t = sum + x;
-    c += Math.abs(sum) >= Math.abs(x) ? sum - t + x : x - t + sum;
-    sum = t;
-    out[i] = sum + c;
-  }
+	let sum = 0;
+	let c = 0;
+	for (let i = 0; i < xs.length; i++) {
+		const x = xs[i];
+		const t = sum + x;
+		c += Math.abs(sum) >= Math.abs(x) ? sum - t + x : x - t + sum;
+		sum = t;
+		out[i] = sum + c;
+	}
 }
-
-// src/index.ts
-var VERSION = "0.18.1";
-export {
-  ALL_UNITS,
-  BASE_UNITS,
-  BEST_PREFIXES,
-  BIGNUMBER_E,
-  BIGNUMBER_LN10,
-  BIGNUMBER_LN2,
-  BIGNUMBER_NEG_ONE,
-  BIGNUMBER_ONE,
-  BIGNUMBER_PI,
-  BIGNUMBER_TEN,
-  BIGNUMBER_ZERO,
-  BigNumber,
-  COMPLEX_NEG_ONE,
-  COMPLEX_ONE,
-  COMPLEX_ZERO,
-  Complex,
-  DEFAULT_CONFIG,
-  DERIVED_UNITS,
-  DIMENSIONLESS,
-  DUAL_UNARY_RULES,
-  DimensionMismatchError,
-  Dual,
-  E,
-  FRACTION_HALF,
-  FRACTION_NEG_ONE,
-  FRACTION_ONE,
-  FRACTION_QUARTER,
-  FRACTION_THIRD,
-  FRACTION_ZERO,
-  Fraction,
-  FunctionRegistry,
-  I,
-  LN10,
-  LN2,
-  LN2_EXACT_SCALE,
-  LOG10E,
-  LOG2E,
-  MATHTS_CONVERSIONS,
-  MATHTS_TYPES,
-  NAMED_IRRATIONALS,
-  NAMED_SCALES,
-  PHI,
-  PI,
-  PI_EXACT_SCALE,
-  Range,
-  SI_DIMENSION_LENGTH,
-  SI_PREFIXES,
-  SQRT1_2,
-  SQRT2,
-  TAU,
-  TypeRegistry,
-  UNIT_ALIASES,
-  UNIT_DIMENSION_LENGTH,
-  UNIT_EXACT_SCALE,
-  UNIT_PREFIX_SETS,
-  UNIT_ROWS,
-  UNIT_ROW_ALIASES,
-  Unit,
-  UnitParseError,
-  VERSION,
-  abs,
-  addExactScales,
-  addScalar,
-  binaryExactScale,
-  clearExactScaleNumberCache,
-  create,
-  createFactory,
-  createMathTSTyped,
-  createRangeClass,
-  createTypedFunction,
-  decimalExactScale,
-  dim,
-  divideExactScales,
-  divideScalar,
-  equal,
-  exactScaleNumberCacheSize,
-  exactScaleOf,
-  exactScaleToNumber,
-  exactScalesEqual,
-  fix,
-  formatExactScale,
-  fromSiDimensionVector,
-  fromSiDimensions,
-  getPrefix,
-  getUnitDef,
-  getUnitPrefix,
-  getUnitRow,
-  initTypedWasm,
-  irrationalPower,
-  isArray,
-  isBigInt2 as isBigInt,
-  isBigNumber2 as isBigNumber,
-  isBoolean,
-  isComplex,
-  isDenseMatrix,
-  isDual,
-  isFraction,
-  isFunction,
-  isMatrix,
-  isNull,
-  isNumber,
-  isNumeric,
-  isObject,
-  isRationalScale,
-  isSparseMatrix,
-  isString,
-  isTypedWasmAvailable,
-  isUndefined,
-  isUnit2 as isUnit,
-  isUnit as isUnitValue,
-  math,
-  mathTyped,
-  multiplyExactScales,
-  multiplyScalar,
-  namedExactScale,
-  namedIrrationalScale,
-  neumaierCumsum,
-  neumaierSum,
-  norm2,
-  number,
-  pairwiseDot,
-  pairwiseSum,
-  pow,
-  powerExactScale,
-  ratioExactScale,
-  readScaleExpression,
-  readUnitScale,
-  registerNativeTypes,
-  registry,
-  round,
-  scaledDistance,
-  subtractScalar,
-  sumSquaredDeviations,
-  toSiDimensionVector,
-  toSiDimensions,
-  typed,
-  unitPrefixExactScale,
-  unitRowExactOffset,
-  unitRowExactScale,
-  unitRowValue
-};
+//#endregion
+//#region src/numeric/rng.ts
+function mulberry32(seed) {
+	let s = seed | 0;
+	return () => {
+		s = s + 1831565813 | 0;
+		let z = s;
+		z = Math.imul(z ^ z >>> 15, z | 1);
+		z ^= z + Math.imul(z ^ z >>> 7, z | 61);
+		z = (z ^ z >>> 14) >>> 0;
+		return z / 4294967296;
+	};
+}
+function boxMuller(u1, u2) {
+	const r = Math.sqrt(-2 * Math.log(u1 === 0 ? Number.EPSILON : u1));
+	const theta = 2 * Math.PI * u2;
+	return [r * Math.cos(theta), r * Math.sin(theta)];
+}
+const FNV_OFFSET = 2166136261;
+const FNV_PRIME = 16777619;
+function fnv1a32(bytes) {
+	let h = FNV_OFFSET;
+	for (let i = 0; i < bytes.length; i++) {
+		h ^= bytes[i];
+		h = Math.imul(h, FNV_PRIME) >>> 0;
+	}
+	return h >>> 0;
+}
+const textEncoder = new TextEncoder();
+function coerceSeedInt(seed) {
+	if (typeof seed === "number") return seed | 0;
+	if (typeof seed === "string") return fnv1a32(textEncoder.encode(seed)) | 0;
+	throw new TypeError("seed must be a number or a string");
+}
+function mixFork(parentSeed, label) {
+	const payload = [
+		parentSeed >>> 0 & 255,
+		parentSeed >>> 8 & 255,
+		parentSeed >>> 16 & 255,
+		parentSeed >>> 24 & 255
+	];
+	if (typeof label === "number") {
+		const n = label | 0;
+		payload.push(0, n >>> 0 & 255, n >>> 8 & 255, n >>> 16 & 255, n >>> 24 & 255);
+	} else if (typeof label === "string") {
+		payload.push(1);
+		for (const b of textEncoder.encode(label)) payload.push(b);
+	} else throw new TypeError("fork label must be a string or a number");
+	return fnv1a32(new Uint8Array(payload)) | 0;
+}
+function makeSeededRng(seedInt) {
+	const uniform = mulberry32(seedInt);
+	let spare = null;
+	return Object.freeze({
+		seed: seedInt,
+		next: () => uniform(),
+		nextInt(maxExclusive) {
+			if (!Number.isInteger(maxExclusive) || maxExclusive < 1 || maxExclusive > 4294967296) throw new RangeError("maxExclusive must be an integer in [1, 4294967296]");
+			return Math.floor(uniform() * maxExclusive);
+		},
+		normal() {
+			if (spare !== null) {
+				const z = spare;
+				spare = null;
+				return z;
+			}
+			const pair = boxMuller(uniform(), uniform());
+			spare = pair[1];
+			return pair[0];
+		},
+		fork(label) {
+			return makeSeededRng(mixFork(seedInt, label));
+		}
+	});
+}
+function createSeededRng(seed) {
+	return makeSeededRng(coerceSeedInt(seed));
+}
+//#endregion
+//#region src/numeric/strides.ts
+function rowMajorStrides(shape) {
+	const strides = new Array(shape.length);
+	let acc = 1;
+	for (let k = shape.length - 1; k >= 0; k--) {
+		strides[k] = acc;
+		acc *= shape[k];
+	}
+	return strides;
+}
+//#endregion
+//#region src/index.ts
+const VERSION = "0.20.0";
+//#endregion
+export { ALL_UNITS, BASE_UNITS, BEST_PREFIXES, BIGNUMBER_E, BIGNUMBER_LN10, BIGNUMBER_LN2, BIGNUMBER_NEG_ONE, BIGNUMBER_ONE, BIGNUMBER_PI, BIGNUMBER_TEN, BIGNUMBER_ZERO, BigNumber, COMPLEX_NEG_ONE, COMPLEX_ONE, COMPLEX_ZERO, Complex, DEFAULT_CONFIG, DERIVED_UNITS, DIMENSIONLESS, DUAL_UNARY_RULES, DimensionMismatchError, Dual, E, FRACTION_HALF, FRACTION_NEG_ONE, FRACTION_ONE, FRACTION_QUARTER, FRACTION_THIRD, FRACTION_ZERO, Fraction, FunctionRegistry, I, LN10, LN2, LN2_EXACT_SCALE, LOG10E, LOG2E, MATHTS_CONVERSIONS, MATHTS_TYPES, NAMED_IRRATIONALS, NAMED_SCALES, PHI, PI, PI_EXACT_SCALE, Range, SI_DIMENSION_LENGTH, SI_PREFIXES, SQRT1_2, SQRT2, TAU, TypeRegistry, UNIT_ALIASES, UNIT_DIMENSION_LENGTH, UNIT_EXACT_SCALE, UNIT_PREFIX_SETS, UNIT_ROWS, UNIT_ROW_ALIASES, Unit, UnitParseError, VERSION, abs, addExactScales, addScalar, binaryExactScale, boxMuller, clearExactScaleNumberCache, create, createFactory, createMathTSTyped, createRangeClass, createSeededRng, createTypedFunction, decimalExactScale, dim, divideExactScales, divideScalar, equal, exactScaleNumberCacheSize, exactScaleOf, exactScaleToNumber, exactScalesEqual, fix, formatExactScale, fromSiDimensionVector, fromSiDimensions, getPrefix, getUnitDef, getUnitPrefix, getUnitRow, initTypedWasm, irrationalPower, isArray, isBigInt, isBigNumber, isBoolean, isComplex, isDenseMatrix, isDual, isFraction, isFunction, isMatrix, isNull, isNumber, isNumeric, isObject, isRationalScale, isSparseMatrix, isString, isTypedWasmAvailable, isUndefined, isUnit, isUnit$1 as isUnitValue, math, mathTyped, mulberry32, multiplyExactScales, multiplyScalar, namedExactScale, namedIrrationalScale, neumaierCumsum, neumaierSum, norm2, number, pairwiseDot, pairwiseSum, pow, powerExactScale, ratioExactScale, readScaleExpression, readUnitScale, registerNativeTypes, registry, round, rowMajorStrides, scaledDistance, subtractScalar, sumSquaredDeviations, toSiDimensionVector, toSiDimensions, typed, unitPrefixExactScale, unitRowExactOffset, unitRowExactScale, unitRowValue };