@danielsimonjr/mathts-core 0.18.1 → 0.20.0

package/dist/internal.js

@@ -1,1640 +1,1147 @@
-import {
-  DEFAULT_CONFIG,
-  MathjsError,
-  Unit,
-  acosh,
-  asinh,
-  assertDependencies,
-  atanh,
-  canDefineProperty,
-  cbrt,
-  clone,
-  copysign,
-  cosh,
-  create,
-  createUnitClass,
-  deepExtend,
-  deepFlatten,
-  deepStrictEqual,
-  digits,
-  endsWith,
-  expm1,
-  extend,
-  factory,
-  format,
-  get,
-  hasOwnProperty,
-  isArray,
-  isBigInt,
-  isBigNumber,
-  isBoolean,
-  isCollection,
-  isComplex,
-  isDate,
-  isDenseMatrix,
-  isFactory,
-  isFraction,
-  isFunction,
-  isIndex,
-  isInteger,
-  isLegacyFactory,
-  isMap,
-  isMatrix,
-  isNull,
-  isNumber,
-  isObject,
-  isOptionalDependency,
-  isPowZeroAtInfinity,
-  isRange,
-  isRegExp,
-  isSparseMatrix,
-  isString,
-  isUndefined,
-  isUnit,
-  lazy,
-  log10,
-  log1p,
-  log2,
-  mapObject,
-  memoize,
-  nearlyEqual,
-  normalizeFormatOptions,
-  pick,
-  pickShallow,
-  roundDigits,
-  safeNumberType,
-  set,
-  sign,
-  sinh,
-  sortFactories,
-  splitNumber,
-  stripOptionalNotation,
-  tanh,
-  toEngineering,
-  toExponential,
-  toFixed,
-  toPrecision,
-  traverse,
-  typeOf,
-  unitDependencies,
-  warnOnce
-} from "./chunk-36FOYJAP.js";
-
-// src/error/DimensionError.ts
-var DimensionError = class _DimensionError extends RangeError {
-  actual;
-  expected;
-  relation;
-  isDimensionError = true;
-  /**
-   * Create a DimensionError. When `actual` is a string and `expected` is not given, the string is the message.
-   *
-   * @param actual - The actual size or custom error message
-   * @param expected - The expected size (optional if actual is a custom message)
-   * @param relation - Optional relation between actual and expected size: '!=', '<', etc.
-   */
-  constructor(actual, expected, relation) {
-    let message;
-    if (typeof actual === "string" && expected === void 0) {
-      message = actual;
-    } else {
-      message = "Dimension mismatch (" + (Array.isArray(actual) ? "[" + actual.join(", ") + "]" : actual) + " " + (relation || "!=") + " " + (Array.isArray(expected) ? "[" + expected.join(", ") + "]" : expected) + ")";
-    }
-    super(message);
-    this.name = "DimensionError";
-    if (typeof actual === "string" && expected === void 0) {
-      this.actual = void 0;
-      this.expected = void 0;
-      this.relation = void 0;
-    } else {
-      this.actual = actual;
-      this.expected = expected;
-      this.relation = relation;
-    }
-    const ErrorWithCapture = Error;
-    if (ErrorWithCapture.captureStackTrace) {
-      ErrorWithCapture.captureStackTrace(this, _DimensionError);
-    }
-  }
+import { $t as log1p, An as isRegExp, At as isLegacyFactory, Bt as warnOnce, Cn as isIndex, Ct as canDefineProperty, Dn as isNumber, Dt as deepStrictEqual, En as isNull, Et as deepFlatten, Fn as typeOf, Ft as set, Gt as copysign, Ht as asinh, It as traverse, Jt as expm1, Kt as cosh, Lt as endsWith, Mn as isString, Mt as mapObject, Nn as isUndefined, Nt as pick, On as isObject, Ot as extend, Pn as isUnit, Pt as pickShallow, Qt as log10, Rt as hasOwnProperty, Sn as isFunction, St as MathjsError, Tn as isMatrix, Tt as deepExtend, Ut as atanh, Vt as acosh, Wt as cbrt, X as DEFAULT_CONFIG, Xt as isInteger, Yt as format, Zt as isPowZeroAtInfinity, _n as isCollection, _t as factory, an as sign, bn as isDenseMatrix, bt as sortFactories, cn as tanh, dn as toFixed, en as log2, fn as toPrecision, gn as isBoolean, gt as create, hn as isBigNumber, ht as assertDependencies, in as safeNumberType, jn as isSparseMatrix, jt as lazy, kn as isRange, kt as get, ln as toEngineering, mn as isBigInt, n as unitDependencies, nn as normalizeFormatOptions, on as sinh, pn as isArray, qt as digits, r as createUnitClass, rn as roundDigits, sn as splitNumber, t as Unit, tn as nearlyEqual, un as toExponential, vn as isComplex, vt as isFactory, wn as isMap, wt as clone, xn as isFraction, xt as stripOptionalNotation, yn as isDate, yt as isOptionalDependency, zt as memoize } from "./unit-Dul_E1rh.js";
+//#region src/error/DimensionError.ts
+var DimensionError = class DimensionError extends RangeError {
+	actual;
+	expected;
+	relation;
+	isDimensionError = true;
+	constructor(actual, expected, relation) {
+		let message;
+		if (typeof actual === "string" && expected === void 0) message = actual;
+		else message = "Dimension mismatch (" + (Array.isArray(actual) ? "[" + actual.join(", ") + "]" : actual) + " " + (relation || "!=") + " " + (Array.isArray(expected) ? "[" + expected.join(", ") + "]" : expected) + ")";
+		super(message);
+		this.name = "DimensionError";
+		if (typeof actual === "string" && expected === void 0) {
+			this.actual = void 0;
+			this.expected = void 0;
+			this.relation = void 0;
+		} else {
+			this.actual = actual;
+			this.expected = expected;
+			this.relation = relation;
+		}
+		const ErrorWithCapture = Error;
+		if (ErrorWithCapture.captureStackTrace) ErrorWithCapture.captureStackTrace(this, DimensionError);
+	}
 };
-
-// src/error/IndexError.ts
-var IndexError = class _IndexError extends RangeError {
-  index;
-  min;
-  max;
-  isIndexError = true;
-  /**
-   * Create an IndexError
-   *
-   * Can be called in two ways:
-   * - IndexError(index, max) - assumes min=0
-   * - IndexError(index, min, max)
-   *
-   * @param index  The actual index
-   * @param min    Minimum index (included), or max if only 2 args provided
-   * @param max    Maximum index (excluded)
-   */
-  constructor(index, min, max) {
-    let actualMin;
-    let actualMax;
-    if (max === void 0) {
-      actualMin = 0;
-      actualMax = min;
-    } else {
-      actualMin = min;
-      actualMax = max;
-    }
-    let message;
-    if (actualMin !== void 0 && index < actualMin) {
-      message = "Index out of range (" + index + " < " + actualMin + ")";
-    } else if (actualMax !== void 0 && index >= actualMax) {
-      message = "Index out of range (" + index + " > " + (actualMax - 1) + ")";
-    } else {
-      message = "Index out of range (" + index + ")";
-    }
-    super(message);
-    this.index = index;
-    this.min = actualMin;
-    this.max = actualMax;
-    this.name = "IndexError";
-    const ErrorWithCapture = Error;
-    if (ErrorWithCapture.captureStackTrace) {
-      ErrorWithCapture.captureStackTrace(this, _IndexError);
-    }
-  }
+//#endregion
+//#region src/error/IndexError.ts
+var IndexError = class IndexError extends RangeError {
+	index;
+	min;
+	max;
+	isIndexError = true;
+	constructor(index, min, max) {
+		let actualMin;
+		let actualMax;
+		if (max === void 0) {
+			actualMin = 0;
+			actualMax = min;
+		} else {
+			actualMin = min;
+			actualMax = max;
+		}
+		let message;
+		if (actualMin !== void 0 && index < actualMin) message = "Index out of range (" + index + " < " + actualMin + ")";
+		else if (actualMax !== void 0 && index >= actualMax) message = "Index out of range (" + index + " > " + (actualMax - 1) + ")";
+		else message = "Index out of range (" + index + ")";
+		super(message);
+		this.index = index;
+		this.min = actualMin;
+		this.max = actualMax;
+		this.name = "IndexError";
+		const ErrorWithCapture = Error;
+		if (ErrorWithCapture.captureStackTrace) ErrorWithCapture.captureStackTrace(this, IndexError);
+	}
 };
 function createIndexError(index, min, max) {
-  return new IndexError(index, min, max);
+	return new IndexError(index, min, max);
 }
-
-// src/bignumber-formatter.ts
+//#endregion
+//#region src/bignumber-formatter.ts
 function ctorOf(n) {
-  return n.constructor;
+	return n.constructor;
 }
 function formatBigNumberToBase(n, base, size) {
-  const BigNumberCtor = ctorOf(n);
-  const big2 = new BigNumberCtor(2);
-  let suffix = "";
-  if (size) {
-    if (size < 1) {
-      throw new Error("size must be in greater than 0");
-    }
-    if (!isInteger(size)) {
-      throw new Error("size must be an integer");
-    }
-    if (n.greaterThan(big2.pow(size - 1).sub(1)) || n.lessThan(big2.pow(size - 1).mul(-1))) {
-      throw new Error(`Value must be in range [-2^${size - 1}, 2^${size - 1}-1]`);
-    }
-    if (!n.isInteger()) {
-      throw new Error("Value must be an integer");
-    }
-    if (n.lessThan(0)) {
-      n = n.add(big2.pow(size));
-    }
-    suffix = `i${size}`;
-  }
-  switch (base) {
-    case 2:
-      return `${n.toBinary()}${suffix}`;
-    case 8:
-      return `${n.toOctal()}${suffix}`;
-    case 16:
-      return `${n.toHexadecimal()}${suffix}`;
-    default:
-      throw new Error(`Base ${base} not supported `);
-  }
-}
-function format2(value, options) {
-  const v = value;
-  if (typeof options === "function") {
-    return options(value);
-  }
-  if (!v.isFinite()) {
-    return v.isNaN() ? "NaN" : v.gt(0) ? "Infinity" : "-Infinity";
-  }
-  const { notation, precision, wordSize } = normalizeFormatOptions(
-    options
-  );
-  switch (notation) {
-    case "fixed":
-      return toFixed2(v, precision);
-    case "exponential":
-      return toExponential2(v, precision);
-    case "engineering":
-      return toEngineering2(v, precision);
-    case "bin":
-      return formatBigNumberToBase(v, 2, wordSize);
-    case "oct":
-      return formatBigNumberToBase(v, 8, wordSize);
-    case "hex":
-      return formatBigNumberToBase(v, 16, wordSize);
-    case "auto": {
-      const optionsObj = options;
-      const lowerExp = isNumber(optionsObj?.lowerExp) || isBigNumber(optionsObj?.lowerExp) ? optionsObj?.lowerExp : -3;
-      const upperExp = isNumber(optionsObj?.upperExp) || isBigNumber(optionsObj?.upperExp) ? optionsObj?.upperExp : 5;
-      if (v.isZero()) return "0";
-      let str;
-      const rounded = v.toSignificantDigits(precision);
-      const exp = rounded.e;
-      let condition;
-      if (isBigNumber(lowerExp) && isBigNumber(upperExp)) {
-        const lowerExpBn = lowerExp;
-        const upperExpBn = upperExp;
-        condition = !lowerExpBn.greaterThan(exp) && upperExpBn.greaterThan(exp);
-      } else if (isBigNumber(lowerExp)) {
-        const lowerExpBn = lowerExp;
-        const upperExpNum = upperExp;
-        condition = !lowerExpBn.greaterThan(exp) && exp < upperExpNum;
-      } else if (isBigNumber(upperExp)) {
-        const upperExpBn = upperExp;
-        const lowerExpNum = lowerExp;
-        condition = exp >= lowerExpNum && upperExpBn.greaterThan(exp);
-      } else {
-        const lowerExpNum = lowerExp;
-        const upperExpNum = upperExp;
-        condition = exp >= lowerExpNum && exp < upperExpNum;
-      }
-      if (condition) {
-        str = rounded.toFixed();
-      } else {
-        str = toExponential2(v, precision);
-      }
-      return str.replace(
-        /((\.\d*?)(0+))($|e)/,
-        function(_match, _g1, digits2, _g3, e) {
-          return digits2 !== "." ? digits2 + e : e;
-        }
-      );
-    }
-    default:
-      throw new Error(
-        'Unknown notation "' + notation + '". Choose "auto", "exponential", "fixed", "bin", "oct", or "hex.'
-      );
-  }
-}
-function toEngineering2(value, precision) {
-  const e = value.e;
-  const newExp = e % 3 === 0 ? e : e < 0 ? e - 3 - e % 3 : e - e % 3;
-  const valueWithoutExp = value.mul(Math.pow(10, -newExp));
-  let valueStr = valueWithoutExp.toPrecision(precision);
-  if (valueStr.includes("e")) {
-    const BigNumberCtor = ctorOf(value);
-    valueStr = new BigNumberCtor(valueStr).toFixed();
-  }
-  return valueStr + "e" + (e >= 0 ? "+" : "") + newExp.toString();
-}
-function toExponential2(value, precision) {
-  if (precision !== void 0) {
-    return value.toExponential(precision - 1);
-  } else {
-    return value.toExponential();
-  }
-}
-function toFixed2(value, precision) {
-  return value.toFixed(precision);
-}
-
-// src/string.ts
-function format3(value, options) {
-  const result = _format(value, options);
-  if (options && typeof options === "object" && "truncate" in options) {
-    const truncate = options.truncate;
-    if (typeof truncate === "number" && result.length > truncate) {
-      return result.substring(0, truncate - 3) + "...";
-    }
-  }
-  return result;
+	const big2 = new (ctorOf(n))(2);
+	let suffix = "";
+	if (size) {
+		if (size < 1) throw new Error("size must be in greater than 0");
+		if (!isInteger(size)) throw new Error("size must be an integer");
+		if (n.greaterThan(big2.pow(size - 1).sub(1)) || n.lessThan(big2.pow(size - 1).mul(-1))) throw new Error(`Value must be in range [-2^${size - 1}, 2^${size - 1}-1]`);
+		if (!n.isInteger()) throw new Error("Value must be an integer");
+		if (n.lessThan(0)) n = n.add(big2.pow(size));
+		suffix = `i${size}`;
+	}
+	switch (base) {
+		case 2: return `${n.toBinary()}${suffix}`;
+		case 8: return `${n.toOctal()}${suffix}`;
+		case 16: return `${n.toHexadecimal()}${suffix}`;
+		default: throw new Error(`Base ${base} not supported `);
+	}
+}
+function format$1(value, options) {
+	const v = value;
+	if (typeof options === "function") return options(value);
+	if (!v.isFinite()) return v.isNaN() ? "NaN" : v.gt(0) ? "Infinity" : "-Infinity";
+	const { notation, precision, wordSize } = normalizeFormatOptions(options);
+	switch (notation) {
+		case "fixed": return toFixed$1(v, precision);
+		case "exponential": return toExponential$1(v, precision);
+		case "engineering": return toEngineering$1(v, precision);
+		case "bin": return formatBigNumberToBase(v, 2, wordSize);
+		case "oct": return formatBigNumberToBase(v, 8, wordSize);
+		case "hex": return formatBigNumberToBase(v, 16, wordSize);
+		case "auto": {
+			const optionsObj = options;
+			const lowerExp = isNumber(optionsObj?.lowerExp) || isBigNumber(optionsObj?.lowerExp) ? optionsObj?.lowerExp : -3;
+			const upperExp = isNumber(optionsObj?.upperExp) || isBigNumber(optionsObj?.upperExp) ? optionsObj?.upperExp : 5;
+			if (v.isZero()) return "0";
+			let str;
+			const rounded = v.toSignificantDigits(precision);
+			const exp = rounded.e;
+			let condition;
+			if (isBigNumber(lowerExp) && isBigNumber(upperExp)) {
+				const lowerExpBn = lowerExp;
+				const upperExpBn = upperExp;
+				condition = !lowerExpBn.greaterThan(exp) && upperExpBn.greaterThan(exp);
+			} else if (isBigNumber(lowerExp)) {
+				const lowerExpBn = lowerExp;
+				const upperExpNum = upperExp;
+				condition = !lowerExpBn.greaterThan(exp) && exp < upperExpNum;
+			} else if (isBigNumber(upperExp)) condition = exp >= lowerExp && upperExp.greaterThan(exp);
+			else condition = exp >= lowerExp && exp < upperExp;
+			if (condition) str = rounded.toFixed();
+			else str = toExponential$1(v, precision);
+			return str.replace(/((\.\d*?)(0+))($|e)/, function(_match, _g1, digits, _g3, e) {
+				return digits !== "." ? digits + e : e;
+			});
+		}
+		default: throw new Error("Unknown notation \"" + notation + "\". Choose \"auto\", \"exponential\", \"fixed\", \"bin\", \"oct\", or \"hex.");
+	}
+}
+function toEngineering$1(value, precision) {
+	const e = value.e;
+	const newExp = e % 3 === 0 ? e : e < 0 ? e - 3 - e % 3 : e - e % 3;
+	let valueStr = value.mul(Math.pow(10, -newExp)).toPrecision(precision);
+	if (valueStr.includes("e")) valueStr = new (ctorOf(value))(valueStr).toFixed();
+	return valueStr + "e" + (e >= 0 ? "+" : "") + newExp.toString();
+}
+function toExponential$1(value, precision) {
+	if (precision !== void 0) return value.toExponential(precision - 1);
+	else return value.toExponential();
+}
+function toFixed$1(value, precision) {
+	return value.toFixed(precision);
+}
+//#endregion
+//#region src/string.ts
+function format$2(value, options) {
+	const result = _format(value, options);
+	if (options && typeof options === "object" && "truncate" in options) {
+		const truncate = options.truncate;
+		if (typeof truncate === "number" && result.length > truncate) return result.substring(0, truncate - 3) + "...";
+	}
+	return result;
 }
 function _format(value, options) {
-  if (typeof value === "number") {
-    return format(value, options);
-  }
-  if (isBigNumber(value)) {
-    return format2(value, options);
-  }
-  if (looksLikeFraction(value)) {
-    if (!options || options.fraction !== "decimal") {
-      const signedNumerator = typeof value.n === "bigint" ? BigInt(value.s) * value.n : value.s * value.n;
-      return `${signedNumerator}/${value.d}`;
-    } else {
-      return value.toString();
-    }
-  }
-  if (Array.isArray(value)) {
-    return formatArray(value, options);
-  }
-  if (isString(value)) {
-    return stringify(value);
-  }
-  if (typeof value === "function") {
-    const syntax = value.syntax;
-    return syntax ? String(syntax) : "function";
-  }
-  if (value && typeof value === "object") {
-    const obj = value;
-    if (typeof obj.format === "function") {
-      return obj.format(options);
-    } else if (obj.toString(options) !== {}.toString()) {
-      return obj.toString(options);
-    } else {
-      const entries = Object.keys(obj).map((key) => {
-        return stringify(key) + ": " + format3(obj[key], options);
-      });
-      return "{" + entries.join(", ") + "}";
-    }
-  }
-  return String(value);
+	if (typeof value === "number") return format(value, options);
+	if (isBigNumber(value)) return format$1(value, options);
+	if (looksLikeFraction(value)) {
+		if (!options || options.fraction !== "decimal") return `${typeof value.n === "bigint" ? BigInt(value.s) * value.n : value.s * value.n}/${value.d}`;
+		else return value.toString();
+	}
+	if (Array.isArray(value)) return formatArray(value, options);
+	if (isString(value)) return stringify(value);
+	if (typeof value === "function") {
+		const syntax = value.syntax;
+		return syntax ? String(syntax) : "function";
+	}
+	if (value && typeof value === "object") {
+		const obj = value;
+		if (typeof obj.format === "function") return obj.format(options);
+		else if (obj.toString(options) !== {}.toString()) return obj.toString(options);
+		else return "{" + Object.keys(obj).map((key) => {
+			return stringify(key) + ": " + format$2(obj[key], options);
+		}).join(", ") + "}";
+	}
+	return String(value);
 }
 function stringify(value) {
-  const text = String(value);
-  let escaped = "";
-  let i = 0;
-  while (i < text.length) {
-    const c = text.charAt(i);
-    escaped += c in controlCharacters ? controlCharacters[c] : c;
-    i++;
-  }
-  return '"' + escaped + '"';
-}
-var controlCharacters = {
-  '"': '\\"',
-  "\\": "\\\\",
-  "\b": "\\b",
-  "\f": "\\f",
-  "\n": "\\n",
-  "\r": "\\r",
-  "	": "\\t"
+	const text = String(value);
+	let escaped = "";
+	let i = 0;
+	while (i < text.length) {
+		const c = text.charAt(i);
+		escaped += c in controlCharacters ? controlCharacters[c] : c;
+		i++;
+	}
+	return "\"" + escaped + "\"";
+}
+const controlCharacters = {
+	"\"": "\\\"",
+	"\\": "\\\\",
+	"\b": "\\b",
+	"\f": "\\f",
+	"\n": "\\n",
+	"\r": "\\r",
+	"	": "\\t"
 };
 function escape(value) {
-  let text = String(value);
-  text = text.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/'/g, "&#39;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-  return text;
+	let text = String(value);
+	text = text.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/'/g, "&#39;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+	return text;
 }
 function formatArray(array, options) {
-  if (Array.isArray(array)) {
-    let str = "[";
-    const len = array.length;
-    for (let i = 0; i < len; i++) {
-      if (i !== 0) {
-        str += ", ";
-      }
-      str += formatArray(array[i], options);
-    }
-    str += "]";
-    return str;
-  } else {
-    return format3(array, options);
-  }
+	if (Array.isArray(array)) {
+		let str = "[";
+		const len = array.length;
+		for (let i = 0; i < len; i++) {
+			if (i !== 0) str += ", ";
+			str += formatArray(array[i], options);
+		}
+		str += "]";
+		return str;
+	} else return format$2(array, options);
 }
 function looksLikeFraction(value) {
-  const frac = value;
-  return !!frac && typeof frac === "object" && typeof frac.s === "bigint" && typeof frac.n === "bigint" && typeof frac.d === "bigint" || false;
+	const frac = value;
+	return !!frac && typeof frac === "object" && typeof frac.s === "bigint" && typeof frac.n === "bigint" && typeof frac.d === "bigint" || false;
 }
 function compareText(x, y) {
-  if (!isString(x)) {
-    throw new TypeError(
-      "Unexpected type of argument in function compareText (expected: string or Array or Matrix, actual: " + typeOf(x) + ", index: 0)"
-    );
-  }
-  if (!isString(y)) {
-    throw new TypeError(
-      "Unexpected type of argument in function compareText (expected: string or Array or Matrix, actual: " + typeOf(y) + ", index: 1)"
-    );
-  }
-  return x === y ? 0 : x > y ? 1 : -1;
-}
-
-// src/array.ts
+	if (!isString(x)) throw new TypeError("Unexpected type of argument in function compareText (expected: string or Array or Matrix, actual: " + typeOf(x) + ", index: 0)");
+	if (!isString(y)) throw new TypeError("Unexpected type of argument in function compareText (expected: string or Array or Matrix, actual: " + typeOf(y) + ", index: 1)");
+	return x === y ? 0 : x > y ? 1 : -1;
+}
+//#endregion
+//#region src/array.ts
 function arraySize(x) {
-  const s = [];
-  let current = x;
-  while (Array.isArray(current)) {
-    s.push(current.length);
-    current = current[0];
-  }
-  return s;
+	const s = [];
+	let current = x;
+	while (Array.isArray(current)) {
+		s.push(current.length);
+		current = current[0];
+	}
+	return s;
 }
 function _validate(array, size, dim) {
-  let i;
-  const len = array.length;
-  if (len !== size[dim]) {
-    throw new DimensionError(len, size[dim]);
-  }
-  if (dim < size.length - 1) {
-    const dimNext = dim + 1;
-    for (i = 0; i < len; i++) {
-      const child = array[i];
-      if (!Array.isArray(child)) {
-        throw new DimensionError(size.length - 1, size.length, "<");
-      }
-      _validate(array[i], size, dimNext);
-    }
-  } else {
-    for (i = 0; i < len; i++) {
-      if (Array.isArray(array[i])) {
-        throw new DimensionError(size.length + 1, size.length, ">");
-      }
-    }
-  }
+	let i;
+	const len = array.length;
+	if (len !== size[dim]) throw new DimensionError(len, size[dim]);
+	if (dim < size.length - 1) {
+		const dimNext = dim + 1;
+		for (i = 0; i < len; i++) {
+			const child = array[i];
+			if (!Array.isArray(child)) throw new DimensionError(size.length - 1, size.length, "<");
+			_validate(array[i], size, dimNext);
+		}
+	} else for (i = 0; i < len; i++) if (Array.isArray(array[i])) throw new DimensionError(size.length + 1, size.length, ">");
 }
 function validate(array, size) {
-  const isScalar = size.length === 0;
-  if (isScalar) {
-    if (Array.isArray(array)) {
-      throw new DimensionError(array.length, 0);
-    }
-  } else {
-    _validate(array, size, 0);
-  }
+	if (size.length === 0) {
+		if (Array.isArray(array)) throw new DimensionError(array.length, 0);
+	} else _validate(array, size, 0);
 }
 function validateIndexSourceSize(value, index) {
-  const valueSize = value.isMatrix ? value._size : arraySize(value);
-  const sourceSize = index._sourceSize;
-  sourceSize.forEach((sourceDim, i) => {
-    if (sourceDim !== null && sourceDim !== valueSize[i]) {
-      throw new DimensionError(sourceDim, valueSize[i]);
-    }
-  });
+	const valueSize = value.isMatrix ? value._size : arraySize(value);
+	index._sourceSize.forEach((sourceDim, i) => {
+		if (sourceDim !== null && sourceDim !== valueSize[i]) throw new DimensionError(sourceDim, valueSize[i]);
+	});
 }
 function validateIndex(index, length) {
-  if (index !== void 0) {
-    if (!isNumber(index) || !isInteger(index)) {
-      throw new TypeError("Index must be an integer (value: " + index + ")");
-    }
-    if (index < 0 || typeof length === "number" && index >= length) {
-      throw new IndexError(index, length);
-    }
-  }
+	if (index !== void 0) {
+		if (!isNumber(index) || !isInteger(index)) throw new TypeError("Index must be an integer (value: " + index + ")");
+		if (index < 0 || typeof length === "number" && index >= length) throw new IndexError(index, length);
+	}
 }
 function isEmptyIndex(index) {
-  for (let i = 0; i < index._dimensions.length; ++i) {
-    const dimension = index._dimensions[i];
-    if (isString(dimension)) {
-      if (dimension.length === 0) {
-        return true;
-      }
-    } else {
-      const dim = dimension;
-      if (dim._data && isArray(dim._data)) {
-        if (dim._size[0] === 0) {
-          return true;
-        }
-      } else if (dim.isRange) {
-        if (dim.start === dim.end) {
-          return true;
-        }
-      }
-    }
-  }
-  return false;
+	for (let i = 0; i < index._dimensions.length; ++i) {
+		const dimension = index._dimensions[i];
+		if (isString(dimension)) {
+			if (dimension.length === 0) return true;
+		} else {
+			const dim = dimension;
+			if (dim._data && isArray(dim._data)) {
+				if (dim._size[0] === 0) return true;
+			} else if (dim.isRange) {
+				if (dim.start === dim.end) return true;
+			}
+		}
+	}
+	return false;
 }
 function resize(array, size, defaultValue) {
-  if (!Array.isArray(size)) {
-    throw new TypeError("Array expected");
-  }
-  if (size.length === 0) {
-    throw new Error("Resizing to scalar is not supported");
-  }
-  size.forEach(function(value) {
-    if (!isNumber(value) || !isInteger(value) || value < 0) {
-      throw new TypeError(
-        "Invalid size, must contain positive integers (size: " + format3(size, {}) + ")"
-      );
-    }
-  });
-  let arr = array;
-  if (isNumber(array) || isBigNumber(array)) {
-    arr = [array];
-  }
-  const _defaultValue = defaultValue !== void 0 ? defaultValue : 0;
-  _resize(arr, size, 0, _defaultValue);
-  return arr;
+	if (!Array.isArray(size)) throw new TypeError("Array expected");
+	if (size.length === 0) throw new Error("Resizing to scalar is not supported");
+	size.forEach(function(value) {
+		if (!isNumber(value) || !isInteger(value) || value < 0) throw new TypeError("Invalid size, must contain positive integers (size: " + format$2(size, {}) + ")");
+	});
+	let arr = array;
+	if (isNumber(array) || isBigNumber(array)) arr = [array];
+	_resize(arr, size, 0, defaultValue !== void 0 ? defaultValue : 0);
+	return arr;
 }
 function _resize(array, size, dim, defaultValue) {
-  let i;
-  let elem;
-  const oldLen = array.length;
-  const newLen = size[dim];
-  const minLen = Math.min(oldLen, newLen);
-  array.length = newLen;
-  if (dim < size.length - 1) {
-    const dimNext = dim + 1;
-    for (i = 0; i < minLen; i++) {
-      let current = array[i];
-      if (!Array.isArray(current)) {
-        current = [current];
-        array[i] = current;
-      }
-      _resize(current, size, dimNext, defaultValue);
-    }
-    for (i = minLen; i < newLen; i++) {
-      elem = [];
-      array[i] = elem;
-      _resize(elem, size, dimNext, defaultValue);
-    }
-  } else {
-    for (i = 0; i < minLen; i++) {
-      let value = array[i];
-      while (Array.isArray(value)) {
-        value = value[0];
-      }
-      array[i] = value;
-    }
-    for (i = minLen; i < newLen; i++) {
-      array[i] = defaultValue;
-    }
-  }
+	let i;
+	let elem;
+	const oldLen = array.length;
+	const newLen = size[dim];
+	const minLen = Math.min(oldLen, newLen);
+	array.length = newLen;
+	if (dim < size.length - 1) {
+		const dimNext = dim + 1;
+		for (i = 0; i < minLen; i++) {
+			let current = array[i];
+			if (!Array.isArray(current)) {
+				current = [current];
+				array[i] = current;
+			}
+			_resize(current, size, dimNext, defaultValue);
+		}
+		for (i = minLen; i < newLen; i++) {
+			elem = [];
+			array[i] = elem;
+			_resize(elem, size, dimNext, defaultValue);
+		}
+	} else {
+		for (i = 0; i < minLen; i++) {
+			let value = array[i];
+			while (Array.isArray(value)) value = value[0];
+			array[i] = value;
+		}
+		for (i = minLen; i < newLen; i++) array[i] = defaultValue;
+	}
 }
 function reshape(array, sizes) {
-  const flatArray = flatten(array, true);
-  const currentLength = flatArray.length;
-  if (!Array.isArray(array) || !Array.isArray(sizes)) {
-    throw new TypeError("Array expected");
-  }
-  if (sizes.length === 0) {
-    throw new DimensionError(0, currentLength, "!=");
-  }
-  const processedSizes = processSizesWildcard(sizes, currentLength);
-  const newLength = product(processedSizes);
-  if (currentLength !== newLength) {
-    throw new DimensionError(newLength, currentLength, "!=");
-  }
-  try {
-    return _reshape(flatArray, processedSizes);
-  } catch (e) {
-    if (e instanceof DimensionError) {
-      const dimErr = new DimensionError(newLength, currentLength, "!=");
-      dimErr.cause = e;
-      throw dimErr;
-    }
-    throw e;
-  }
+	const flatArray = flatten(array, true);
+	const currentLength = flatArray.length;
+	if (!Array.isArray(array) || !Array.isArray(sizes)) throw new TypeError("Array expected");
+	if (sizes.length === 0) throw new DimensionError(0, currentLength, "!=");
+	const processedSizes = processSizesWildcard(sizes, currentLength);
+	const newLength = product(processedSizes);
+	if (currentLength !== newLength) throw new DimensionError(newLength, currentLength, "!=");
+	try {
+		return _reshape(flatArray, processedSizes);
+	} catch (e) {
+		if (e instanceof DimensionError) {
+			const dimErr = new DimensionError(newLength, currentLength, "!=");
+			dimErr.cause = e;
+			throw dimErr;
+		}
+		throw e;
+	}
 }
 function processSizesWildcard(sizes, currentLength) {
-  const newLength = product(sizes);
-  const processedSizes = sizes.slice();
-  const WILDCARD = -1;
-  const wildCardIndex = sizes.indexOf(WILDCARD);
-  const isMoreThanOneWildcard = sizes.indexOf(WILDCARD, wildCardIndex + 1) >= 0;
-  if (isMoreThanOneWildcard) {
-    throw new Error("More than one wildcard in sizes");
-  }
-  const hasWildcard = wildCardIndex >= 0;
-  const canReplaceWildcard = currentLength % newLength === 0;
-  if (hasWildcard) {
-    if (canReplaceWildcard) {
-      processedSizes[wildCardIndex] = -currentLength / newLength;
-    } else {
-      throw new Error(
-        "Could not replace wildcard, since " + currentLength + " is no multiple of " + -newLength
-      );
-    }
-  }
-  return processedSizes;
+	const newLength = product(sizes);
+	const processedSizes = sizes.slice();
+	const WILDCARD = -1;
+	const wildCardIndex = sizes.indexOf(WILDCARD);
+	if (sizes.indexOf(WILDCARD, wildCardIndex + 1) >= 0) throw new Error("More than one wildcard in sizes");
+	const hasWildcard = wildCardIndex >= 0;
+	const canReplaceWildcard = currentLength % newLength === 0;
+	if (hasWildcard) {
+		if (canReplaceWildcard) processedSizes[wildCardIndex] = -currentLength / newLength;
+		else throw new Error("Could not replace wildcard, since " + currentLength + " is no multiple of " + -newLength);
+	}
+	return processedSizes;
 }
 function product(array) {
-  return array.reduce((prev, curr) => prev * curr, 1);
+	return array.reduce((prev, curr) => prev * curr, 1);
 }
 function _reshape(array, sizes) {
-  let tmpArray = array;
-  let tmpArray2;
-  for (let sizeIndex = sizes.length - 1; sizeIndex > 0; sizeIndex--) {
-    const size = sizes[sizeIndex];
-    tmpArray2 = [];
-    const length = tmpArray.length / size;
-    for (let i = 0; i < length; i++) {
-      tmpArray2.push(tmpArray.slice(i * size, (i + 1) * size));
-    }
-    tmpArray = tmpArray2;
-  }
-  return tmpArray;
+	let tmpArray = array;
+	let tmpArray2;
+	for (let sizeIndex = sizes.length - 1; sizeIndex > 0; sizeIndex--) {
+		const size = sizes[sizeIndex];
+		tmpArray2 = [];
+		const length = tmpArray.length / size;
+		for (let i = 0; i < length; i++) tmpArray2.push(tmpArray.slice(i * size, (i + 1) * size));
+		tmpArray = tmpArray2;
+	}
+	return tmpArray;
 }
 function squeeze(array, size) {
-  const s = size || arraySize(array);
-  let arr = array;
-  while (Array.isArray(arr) && arr.length === 1) {
-    arr = arr[0];
-    s.shift();
-  }
-  let dims = s.length;
-  while (s[dims - 1] === 1) {
-    dims--;
-  }
-  if (dims < s.length) {
-    arr = _squeeze(arr, dims, 0);
-    s.length = dims;
-  }
-  return arr;
+	const s = size || arraySize(array);
+	let arr = array;
+	while (Array.isArray(arr) && arr.length === 1) {
+		arr = arr[0];
+		s.shift();
+	}
+	let dims = s.length;
+	while (s[dims - 1] === 1) dims--;
+	if (dims < s.length) {
+		arr = _squeeze(arr, dims, 0);
+		s.length = dims;
+	}
+	return arr;
 }
 function _squeeze(array, dims, dim) {
-  if (dim < dims) {
-    const next = dim + 1;
-    const arr = array;
-    for (let i = 0, ii = arr.length; i < ii; i++) {
-      arr[i] = _squeeze(arr[i], dims, next);
-    }
-    return arr;
-  } else {
-    let result = array;
-    while (Array.isArray(result)) {
-      result = result[0];
-    }
-    return result;
-  }
+	if (dim < dims) {
+		const next = dim + 1;
+		const arr = array;
+		for (let i = 0, ii = arr.length; i < ii; i++) arr[i] = _squeeze(arr[i], dims, next);
+		return arr;
+	} else {
+		let result = array;
+		while (Array.isArray(result)) result = result[0];
+		return result;
+	}
 }
 function unsqueeze(array, dims, outer, size) {
-  const s = size || arraySize(array);
-  let arr = array;
-  if (outer) {
-    for (let i = 0; i < outer; i++) {
-      arr = [arr];
-      s.unshift(1);
-    }
-  }
-  arr = _unsqueeze(arr, dims, 0);
-  while (s.length < dims) {
-    s.push(1);
-  }
-  return arr;
+	const s = size || arraySize(array);
+	let arr = array;
+	if (outer) for (let i = 0; i < outer; i++) {
+		arr = [arr];
+		s.unshift(1);
+	}
+	arr = _unsqueeze(arr, dims, 0);
+	while (s.length < dims) s.push(1);
+	return arr;
 }
 function _unsqueeze(array, dims, dim) {
-  if (Array.isArray(array)) {
-    const next = dim + 1;
-    const arr = array;
-    for (let i = 0, ii = arr.length; i < ii; i++) {
-      arr[i] = _unsqueeze(arr[i], dims, next);
-    }
-    return arr;
-  } else {
-    let result = array;
-    for (let d = dim; d < dims; d++) {
-      result = [result];
-    }
-    return result;
-  }
+	if (Array.isArray(array)) {
+		const next = dim + 1;
+		const arr = array;
+		for (let i = 0, ii = arr.length; i < ii; i++) arr[i] = _unsqueeze(arr[i], dims, next);
+		return arr;
+	} else {
+		let result = array;
+		for (let d = dim; d < dims; d++) result = [result];
+		return result;
+	}
 }
 function flatten(array, isRectangular = false) {
-  if (!Array.isArray(array)) {
-    return array;
-  }
-  if (typeof isRectangular !== "boolean") {
-    throw new TypeError("Boolean expected for second argument of flatten");
-  }
-  const flat = [];
-  if (isRectangular) {
-    _flattenRectangular(array);
-  } else {
-    _flatten(array);
-  }
-  return flat;
-  function _flatten(arr) {
-    for (let i = 0; i < arr.length; i++) {
-      const item = arr[i];
-      if (Array.isArray(item)) {
-        _flatten(item);
-      } else {
-        flat.push(item);
-      }
-    }
-  }
-  function _flattenRectangular(arr) {
-    if (Array.isArray(arr[0])) {
-      for (let i = 0; i < arr.length; i++) {
-        _flattenRectangular(arr[i]);
-      }
-    } else {
-      for (let i = 0; i < arr.length; i++) {
-        flat.push(arr[i]);
-      }
-    }
-  }
+	if (!Array.isArray(array)) return array;
+	if (typeof isRectangular !== "boolean") throw new TypeError("Boolean expected for second argument of flatten");
+	const flat = [];
+	if (isRectangular) _flattenRectangular(array);
+	else _flatten(array);
+	return flat;
+	function _flatten(arr) {
+		for (let i = 0; i < arr.length; i++) {
+			const item = arr[i];
+			if (Array.isArray(item)) _flatten(item);
+			else flat.push(item);
+		}
+	}
+	function _flattenRectangular(arr) {
+		if (Array.isArray(arr[0])) for (let i = 0; i < arr.length; i++) _flattenRectangular(arr[i]);
+		else for (let i = 0; i < arr.length; i++) flat.push(arr[i]);
+	}
 }
 function map(array, callback) {
-  return Array.prototype.map.call(array, callback);
+	return Array.prototype.map.call(array, callback);
 }
 function forEach(array, callback) {
-  Array.prototype.forEach.call(array, callback);
+	Array.prototype.forEach.call(array, callback);
 }
 function filter(array, callback) {
-  if (arraySize(array).length !== 1) {
-    throw new Error("Only one dimensional matrices supported");
-  }
-  return Array.prototype.filter.call(array, callback);
+	if (arraySize(array).length !== 1) throw new Error("Only one dimensional matrices supported");
+	return Array.prototype.filter.call(array, callback);
 }
 function filterRegExp(array, regexp) {
-  if (arraySize(array).length !== 1) {
-    throw new Error("Only one dimensional matrices supported");
-  }
-  return Array.prototype.filter.call(array, (entry) => regexp.test(entry));
+	if (arraySize(array).length !== 1) throw new Error("Only one dimensional matrices supported");
+	return Array.prototype.filter.call(array, (entry) => regexp.test(entry));
 }
 function join(array, separator) {
-  return Array.prototype.join.call(array, separator);
+	return Array.prototype.join.call(array, separator);
 }
 function identify(a) {
-  if (!Array.isArray(a)) {
-    throw new TypeError("Array input expected");
-  }
-  if (a.length === 0) {
-    return [];
-  }
-  const b = [];
-  let count = 0;
-  b[0] = { value: a[0], identifier: 0 };
-  for (let i = 1; i < a.length; i++) {
-    if (a[i] === a[i - 1]) {
-      count++;
-    } else {
-      count = 0;
-    }
-    b.push({ value: a[i], identifier: count });
-  }
-  return b;
+	if (!Array.isArray(a)) throw new TypeError("Array input expected");
+	if (a.length === 0) return [];
+	const b = [];
+	let count = 0;
+	b[0] = {
+		value: a[0],
+		identifier: 0
+	};
+	for (let i = 1; i < a.length; i++) {
+		if (a[i] === a[i - 1]) count++;
+		else count = 0;
+		b.push({
+			value: a[i],
+			identifier: count
+		});
+	}
+	return b;
 }
 function generalize(a) {
-  if (!Array.isArray(a)) {
-    throw new TypeError("Array input expected");
-  }
-  if (a.length === 0) {
-    return [];
-  }
-  const b = [];
-  for (let i = 0; i < a.length; i++) {
-    b.push(a[i].value);
-  }
-  return b;
-}
-function getArrayDataType(array, typeOf2) {
-  let type;
-  let length = 0;
-  for (let i = 0; i < array.length; i++) {
-    const item = array[i];
-    const isArray2 = Array.isArray(item);
-    if (i === 0 && isArray2) {
-      length = item.length;
-    }
-    if (isArray2 && item.length !== length) {
-      return void 0;
-    }
-    const itemType = isArray2 ? getArrayDataType(item, typeOf2) : typeOf2(item);
-    if (type === void 0) {
-      type = itemType;
-    } else if (type !== itemType) {
-      return "mixed";
-    } else {
-    }
-  }
-  return type;
+	if (!Array.isArray(a)) throw new TypeError("Array input expected");
+	if (a.length === 0) return [];
+	const b = [];
+	for (let i = 0; i < a.length; i++) b.push(a[i].value);
+	return b;
+}
+function getArrayDataType(array, typeOf) {
+	let type;
+	let length = 0;
+	for (let i = 0; i < array.length; i++) {
+		const item = array[i];
+		const isArray = Array.isArray(item);
+		if (i === 0 && isArray) length = item.length;
+		if (isArray && item.length !== length) return;
+		const itemType = isArray ? getArrayDataType(item, typeOf) : typeOf(item);
+		if (type === void 0) type = itemType;
+		else if (type !== itemType) return "mixed";
+	}
+	return type;
 }
 function last(array) {
-  return array[array.length - 1];
+	return array[array.length - 1];
 }
 function initial(array) {
-  return array.slice(0, array.length - 1);
+	return array.slice(0, array.length - 1);
 }
 function concatRecursive(a, b, concatDim, dim) {
-  if (dim < concatDim) {
-    if (a.length !== b.length) {
-      throw new DimensionError(a.length, b.length);
-    }
-    const c = [];
-    for (let i = 0; i < a.length; i++) {
-      c[i] = concatRecursive(
-        a[i],
-        b[i],
-        concatDim,
-        dim + 1
-      );
-    }
-    return c;
-  } else {
-    return a.concat(b);
-  }
+	if (dim < concatDim) {
+		if (a.length !== b.length) throw new DimensionError(a.length, b.length);
+		const c = [];
+		for (let i = 0; i < a.length; i++) c[i] = concatRecursive(a[i], b[i], concatDim, dim + 1);
+		return c;
+	} else return a.concat(b);
 }
 function concat(...args) {
-  const arrays = Array.prototype.slice.call(args, 0, -1);
-  const concatDim = Array.prototype.slice.call(args, -1)[0];
-  if (arrays.length === 1) {
-    return arrays[0];
-  }
-  if (arrays.length > 1) {
-    return arrays.slice(1).reduce(function(A, B) {
-      return concatRecursive(A, B, concatDim, 0);
-    }, arrays[0]);
-  } else {
-    throw new Error("Wrong number of arguments in function concat");
-  }
+	const arrays = Array.prototype.slice.call(args, 0, -1);
+	const concatDim = Array.prototype.slice.call(args, -1)[0];
+	if (arrays.length === 1) return arrays[0];
+	if (arrays.length > 1) return arrays.slice(1).reduce(function(A, B) {
+		return concatRecursive(A, B, concatDim, 0);
+	}, arrays[0]);
+	else throw new Error("Wrong number of arguments in function concat");
 }
 function broadcastSizes(...sizes) {
-  const dimensions = sizes.map((s) => s.length);
-  const N = Math.max(...dimensions);
-  const sizeMax = new Array(N).fill(null);
-  for (let i = 0; i < sizes.length; i++) {
-    const size = sizes[i];
-    const dim = dimensions[i];
-    for (let j = 0; j < dim; j++) {
-      const n = N - dim + j;
-      if (size[j] > sizeMax[n]) {
-        sizeMax[n] = size[j];
-      }
-    }
-  }
-  for (let i = 0; i < sizes.length; i++) {
-    checkBroadcastingRules(sizes[i], sizeMax);
-  }
-  return sizeMax;
+	const dimensions = sizes.map((s) => s.length);
+	const N = Math.max(...dimensions);
+	const sizeMax = new Array(N).fill(null);
+	for (let i = 0; i < sizes.length; i++) {
+		const size = sizes[i];
+		const dim = dimensions[i];
+		for (let j = 0; j < dim; j++) {
+			const n = N - dim + j;
+			if (size[j] > sizeMax[n]) sizeMax[n] = size[j];
+		}
+	}
+	for (let i = 0; i < sizes.length; i++) checkBroadcastingRules(sizes[i], sizeMax);
+	return sizeMax;
 }
 function checkBroadcastingRules(size, toSize) {
-  const N = toSize.length;
-  const dim = size.length;
-  for (let j = 0; j < dim; j++) {
-    const n = N - dim + j;
-    if (size[j] < toSize[n] && size[j] > 1 || size[j] > toSize[n]) {
-      throw new Error(
-        `shape mismatch: mismatch is found in arg with shape (${size}) not possible to broadcast dimension ${dim} with size ${size[j]} to size ${toSize[n]}`
-      );
-    }
-  }
+	const N = toSize.length;
+	const dim = size.length;
+	for (let j = 0; j < dim; j++) {
+		const n = N - dim + j;
+		if (size[j] < toSize[n] && size[j] > 1 || size[j] > toSize[n]) throw new Error(`shape mismatch: mismatch is found in arg with shape (${size}) not possible to broadcast dimension ${dim} with size ${size[j]} to size ${toSize[n]}`);
+	}
 }
 function broadcastTo(array, toSize) {
-  let Asize = arraySize(array);
-  if (deepStrictEqual(Asize, toSize)) {
-    return array;
-  }
-  checkBroadcastingRules(Asize, toSize);
-  const broadcastedSize = broadcastSizes(Asize, toSize);
-  const N = broadcastedSize.length;
-  const paddedSize = [...Array(N - Asize.length).fill(1), ...Asize];
-  let A = clone2(array);
-  if (Asize.length < N) {
-    A = reshape(A, paddedSize);
-    Asize = arraySize(A);
-  }
-  for (let dim = 0; dim < N; dim++) {
-    if (Asize[dim] < broadcastedSize[dim]) {
-      A = stretch(A, broadcastedSize[dim], dim);
-      Asize = arraySize(A);
-    }
-  }
-  return A;
+	let Asize = arraySize(array);
+	if (deepStrictEqual(Asize, toSize)) return array;
+	checkBroadcastingRules(Asize, toSize);
+	const broadcastedSize = broadcastSizes(Asize, toSize);
+	const N = broadcastedSize.length;
+	const paddedSize = [...Array(N - Asize.length).fill(1), ...Asize];
+	let A = clone$1(array);
+	if (Asize.length < N) {
+		A = reshape(A, paddedSize);
+		Asize = arraySize(A);
+	}
+	for (let dim = 0; dim < N; dim++) if (Asize[dim] < broadcastedSize[dim]) {
+		A = stretch(A, broadcastedSize[dim], dim);
+		Asize = arraySize(A);
+	}
+	return A;
 }
 function broadcastArrays(...arrays) {
-  if (arrays.length === 0) {
-    throw new Error("Insufficient number of arguments in function broadcastArrays");
-  }
-  if (arrays.length === 1) {
-    return arrays[0];
-  }
-  const sizes = arrays.map(function(array) {
-    return arraySize(array);
-  });
-  const broadcastedSize = broadcastSizes(...sizes);
-  const broadcastedArrays = [];
-  arrays.forEach(function(array) {
-    broadcastedArrays.push(broadcastTo(array, broadcastedSize));
-  });
-  return broadcastedArrays;
+	if (arrays.length === 0) throw new Error("Insufficient number of arguments in function broadcastArrays");
+	if (arrays.length === 1) return arrays[0];
+	const broadcastedSize = broadcastSizes(...arrays.map(function(array) {
+		return arraySize(array);
+	}));
+	const broadcastedArrays = [];
+	arrays.forEach(function(array) {
+		broadcastedArrays.push(broadcastTo(array, broadcastedSize));
+	});
+	return broadcastedArrays;
 }
 function stretch(arrayToStretch, sizeToStretch, dimToStretch) {
-  return concat(...Array(sizeToStretch).fill(arrayToStretch), dimToStretch);
-}
-function get2(array, index) {
-  if (!Array.isArray(array)) {
-    throw new Error("Array expected");
-  }
-  const size = arraySize(array);
-  if (index.length !== size.length) {
-    throw new DimensionError(index.length, size.length);
-  }
-  for (let x = 0; x < index.length; x++) {
-    validateIndex(index[x], size[x]);
-  }
-  return index.reduce((acc, curr) => acc[curr], array);
-}
-function deepMap(array, callback, skipIndex = false) {
-  if (Array.isArray(array) && array.length === 0) {
-    return [];
-  }
-  if (skipIndex) {
-    return recursiveMap(array);
-  }
-  const index = [];
-  return recursiveMapWithIndex(array, 0);
-  function recursiveMapWithIndex(value, depth) {
-    if (Array.isArray(value)) {
-      const N = value.length;
-      const result = Array(N);
-      for (let i = 0; i < N; i++) {
-        index[depth] = i;
-        result[i] = recursiveMapWithIndex(value[i], depth + 1);
-      }
-      return result;
-    } else {
-      return callback(
-        value,
-        index.slice(0, depth),
-        array
-      );
-    }
-  }
-  function recursiveMap(value) {
-    if (Array.isArray(value)) {
-      const N = value.length;
-      const result = Array(N);
-      for (let i = 0; i < N; i++) {
-        result[i] = recursiveMap(value[i]);
-      }
-      return result;
-    } else {
-      return callback(value);
-    }
-  }
-}
-function deepForEach(array, callback, skipIndex = false) {
-  if (Array.isArray(array) && array.length === 0) {
-    return;
-  }
-  if (skipIndex) {
-    recursiveForEach(array);
-    return;
-  }
-  const index = [];
-  recursiveForEachWithIndex(array, 0);
-  function recursiveForEachWithIndex(value, depth) {
-    if (Array.isArray(value)) {
-      const N = value.length;
-      for (let i = 0; i < N; i++) {
-        index[depth] = i;
-        recursiveForEachWithIndex(value[i], depth + 1);
-      }
-    } else {
-      callback(
-        value,
-        index.slice(0, depth),
-        array
-      );
-    }
-  }
-  function recursiveForEach(value) {
-    if (Array.isArray(value)) {
-      const N = value.length;
-      for (let i = 0; i < N; i++) {
-        recursiveForEach(value[i]);
-      }
-    } else {
-      callback(value);
-    }
-  }
-}
-function clone2(array) {
-  return Object.assign([], array);
-}
-
-// src/switch.ts
+	return concat(...Array(sizeToStretch).fill(arrayToStretch), dimToStretch);
+}
+function get$1(array, index) {
+	if (!Array.isArray(array)) throw new Error("Array expected");
+	const size = arraySize(array);
+	if (index.length !== size.length) throw new DimensionError(index.length, size.length);
+	for (let x = 0; x < index.length; x++) validateIndex(index[x], size[x]);
+	return index.reduce((acc, curr) => acc[curr], array);
+}
+function deepMap$1(array, callback, skipIndex = false) {
+	if (Array.isArray(array) && array.length === 0) return [];
+	if (skipIndex) return recursiveMap(array);
+	const index = [];
+	return recursiveMapWithIndex(array, 0);
+	function recursiveMapWithIndex(value, depth) {
+		if (Array.isArray(value)) {
+			const N = value.length;
+			const result = Array(N);
+			for (let i = 0; i < N; i++) {
+				index[depth] = i;
+				result[i] = recursiveMapWithIndex(value[i], depth + 1);
+			}
+			return result;
+		} else return callback(value, index.slice(0, depth), array);
+	}
+	function recursiveMap(value) {
+		if (Array.isArray(value)) {
+			const N = value.length;
+			const result = Array(N);
+			for (let i = 0; i < N; i++) result[i] = recursiveMap(value[i]);
+			return result;
+		} else return callback(value);
+	}
+}
+function deepForEach$1(array, callback, skipIndex = false) {
+	if (Array.isArray(array) && array.length === 0) return;
+	if (skipIndex) {
+		recursiveForEach(array);
+		return;
+	}
+	const index = [];
+	recursiveForEachWithIndex(array, 0);
+	function recursiveForEachWithIndex(value, depth) {
+		if (Array.isArray(value)) {
+			const N = value.length;
+			for (let i = 0; i < N; i++) {
+				index[depth] = i;
+				recursiveForEachWithIndex(value[i], depth + 1);
+			}
+		} else callback(value, index.slice(0, depth), array);
+	}
+	function recursiveForEach(value) {
+		if (Array.isArray(value)) {
+			const N = value.length;
+			for (let i = 0; i < N; i++) recursiveForEach(value[i]);
+		} else callback(value);
+	}
+}
+function clone$1(array) {
+	return Object.assign([], array);
+}
+//#endregion
+//#region src/switch.ts
 function _switch(mat) {
-  const I = mat.length;
-  const J = mat[0].length;
-  let i, j;
-  const ret = [];
-  for (j = 0; j < J; j++) {
-    const tmp = [];
-    for (i = 0; i < I; i++) {
-      tmp.push(mat[i][j]);
-    }
-    ret.push(tmp);
-  }
-  return ret;
-}
-
-// src/collection.ts
+	const I = mat.length;
+	const J = mat[0].length;
+	let i, j;
+	const ret = [];
+	for (j = 0; j < J; j++) {
+		const tmp = [];
+		for (i = 0; i < I; i++) tmp.push(mat[i][j]);
+		ret.push(tmp);
+	}
+	return ret;
+}
+//#endregion
+//#region src/collection.ts
 function containsCollections(array) {
-  for (let i = 0; i < array.length; i++) {
-    if (isCollection(array[i])) {
-      return true;
-    }
-  }
-  return false;
-}
-function deepForEach2(array, callback) {
-  if (isMatrix(array)) {
-    array.forEach((x) => callback(x), false, true);
-  } else {
-    deepForEach(array, callback, true);
-  }
-}
-function deepMap2(array, callback, skipZeros) {
-  if (!skipZeros) {
-    if (isMatrix(array)) {
-      return array.map((x) => callback(x), false, true);
-    } else {
-      return deepMap(array, callback, true);
-    }
-  }
-  const skipZerosCallback = (x) => x === 0 ? x : callback(x);
-  if (isMatrix(array)) {
-    return array.map((x) => skipZerosCallback(x), false, true);
-  } else {
-    return deepMap(array, skipZerosCallback, true);
-  }
+	for (let i = 0; i < array.length; i++) if (isCollection(array[i])) return true;
+	return false;
+}
+function deepForEach(array, callback) {
+	if (isMatrix(array)) array.forEach((x) => callback(x), false, true);
+	else deepForEach$1(array, callback, true);
+}
+function deepMap(array, callback, skipZeros) {
+	if (!skipZeros) {
+		if (isMatrix(array)) return array.map((x) => callback(x), false, true);
+		else return deepMap$1(array, callback, true);
+	}
+	const skipZerosCallback = (x) => x === 0 ? x : callback(x);
+	if (isMatrix(array)) return array.map((x) => skipZerosCallback(x), false, true);
+	else return deepMap$1(array, skipZerosCallback, true);
 }
 function reduce(mat, dim, callback) {
-  const size = Array.isArray(mat) ? arraySize(mat) : mat.size();
-  if (dim < 0 || dim >= size.length) {
-    throw new DimensionError(dim, size.length, "<");
-  }
-  if (isMatrix(mat)) {
-    const reduced = _reduce(mat.valueOf(), dim, callback);
-    return mat.create(
-      reduced,
-      mat.datatype()
-    );
-  } else {
-    return _reduce(mat, dim, callback);
-  }
+	const size = Array.isArray(mat) ? arraySize(mat) : mat.size();
+	if (dim < 0 || dim >= size.length) throw new DimensionError(dim, size.length, "<");
+	if (isMatrix(mat)) {
+		const reduced = _reduce(mat.valueOf(), dim, callback);
+		return mat.create(reduced, mat.datatype());
+	} else return _reduce(mat, dim, callback);
 }
 function _reduce(mat, dim, callback) {
-  let i;
-  let ret;
-  let val;
-  let tran;
-  if (dim <= 0) {
-    if (!Array.isArray(mat[0])) {
-      val = mat[0];
-      for (i = 1; i < mat.length; i++) {
-        val = callback(val, mat[i]);
-      }
-      return val;
-    } else {
-      tran = _switch(mat);
-      ret = [];
-      for (i = 0; i < tran.length; i++) {
-        ret[i] = _reduce(tran[i], dim - 1, callback);
-      }
-      return ret;
-    }
-  } else {
-    ret = [];
-    for (i = 0; i < mat.length; i++) {
-      ret[i] = _reduce(mat[i], dim - 1, callback);
-    }
-    return ret;
-  }
+	let i;
+	let ret;
+	let val;
+	let tran;
+	if (dim <= 0) {
+		if (!Array.isArray(mat[0])) {
+			val = mat[0];
+			for (i = 1; i < mat.length; i++) val = callback(val, mat[i]);
+			return val;
+		} else {
+			tran = _switch(mat);
+			ret = [];
+			for (i = 0; i < tran.length; i++) ret[i] = _reduce(tran[i], dim - 1, callback);
+			return ret;
+		}
+	} else {
+		ret = [];
+		for (i = 0; i < mat.length; i++) ret[i] = _reduce(mat[i], dim - 1, callback);
+		return ret;
+	}
 }
 function scatter(a, j, w, x, u, mark, cindex, f, inverse, update, value) {
-  const avalues = a._values;
-  const aindex = a._index;
-  const aptr = a._ptr;
-  let k;
-  let k0;
-  let k1;
-  let i;
-  if (x) {
-    for (k0 = aptr[j], k1 = aptr[j + 1], k = k0; k < k1; k++) {
-      i = aindex[k];
-      if (w[i] !== mark) {
-        w[i] = mark;
-        cindex.push(i);
-        if (update && f) {
-          x[i] = inverse ? f(avalues[k], value) : f(value, avalues[k]);
-          u[i] = mark;
-        } else {
-          x[i] = avalues[k];
-        }
-      } else {
-        if (f) {
-          x[i] = inverse ? f(avalues[k], x[i]) : f(x[i], avalues[k]);
-        }
-        u[i] = mark;
-      }
-    }
-  } else {
-    for (k0 = aptr[j], k1 = aptr[j + 1], k = k0; k < k1; k++) {
-      i = aindex[k];
-      if (w[i] !== mark) {
-        w[i] = mark;
-        cindex.push(i);
-      } else {
-        u[i] = mark;
-      }
-    }
-  }
-}
-
-// src/customs.ts
+	const avalues = a._values;
+	const aindex = a._index;
+	const aptr = a._ptr;
+	let k;
+	let k0;
+	let k1;
+	let i;
+	if (x) for (k0 = aptr[j], k1 = aptr[j + 1], k = k0; k < k1; k++) {
+		i = aindex[k];
+		if (w[i] !== mark) {
+			w[i] = mark;
+			cindex.push(i);
+			if (update && f) {
+				x[i] = inverse ? f(avalues[k], value) : f(value, avalues[k]);
+				u[i] = mark;
+			} else x[i] = avalues[k];
+		} else {
+			if (f) x[i] = inverse ? f(avalues[k], x[i]) : f(x[i], avalues[k]);
+			u[i] = mark;
+		}
+	}
+	else for (k0 = aptr[j], k1 = aptr[j + 1], k = k0; k < k1; k++) {
+		i = aindex[k];
+		if (w[i] !== mark) {
+			w[i] = mark;
+			cindex.push(i);
+		} else u[i] = mark;
+	}
+}
+//#endregion
+//#region src/customs.ts
 function getSafeProperty(object, prop) {
-  const obj = object;
-  if (isSafeProperty(object, prop)) {
-    return obj[prop];
-  }
-  if (typeof obj[prop] === "function" && isSafeMethod(object, prop)) {
-    throw new Error('Cannot access method "' + prop + '" as a property');
-  }
-  throw new Error('No access to property "' + prop + '"');
+	const obj = object;
+	if (isSafeProperty(object, prop)) return obj[prop];
+	if (typeof obj[prop] === "function" && isSafeMethod(object, prop)) throw new Error("Cannot access method \"" + prop + "\" as a property");
+	throw new Error("No access to property \"" + prop + "\"");
 }
 function setSafeProperty(object, prop, value) {
-  if (isSafeProperty(object, prop)) {
-    object[prop] = value;
-    return value;
-  }
-  throw new Error('No access to property "' + prop + '"');
+	if (isSafeProperty(object, prop)) {
+		object[prop] = value;
+		return value;
+	}
+	throw new Error("No access to property \"" + prop + "\"");
 }
 function isSafeProperty(object, prop) {
-  if (!isPlainObject(object) && !Array.isArray(object)) {
-    return false;
-  }
-  if (hasOwnProperty(safeNativeProperties, prop)) {
-    return true;
-  }
-  if (prop in Object.prototype) {
-    return false;
-  }
-  if (prop in Function.prototype) {
-    return false;
-  }
-  return true;
+	if (!isPlainObject(object) && !Array.isArray(object)) return false;
+	if (hasOwnProperty(safeNativeProperties, prop)) return true;
+	if (prop in Object.prototype) return false;
+	if (prop in Function.prototype) return false;
+	return true;
 }
 function isSafeMethod(object, method) {
-  if (object === null || object === void 0 || typeof object[method] !== "function") {
-    return false;
-  }
-  if (hasOwnProperty(object, method) && Object.getPrototypeOf && method in Object.getPrototypeOf(object)) {
-    return false;
-  }
-  if (hasOwnProperty(safeNativeMethods, method)) {
-    return true;
-  }
-  if (method in Object.prototype) {
-    return false;
-  }
-  if (method in Function.prototype) {
-    return false;
-  }
-  return true;
+	if (object === null || object === void 0 || typeof object[method] !== "function") return false;
+	if (hasOwnProperty(object, method) && Object.getPrototypeOf && method in Object.getPrototypeOf(object)) return false;
+	if (hasOwnProperty(safeNativeMethods, method)) return true;
+	if (method in Object.prototype) return false;
+	if (method in Function.prototype) return false;
+	return true;
 }
 function isPlainObject(object) {
-  return typeof object === "object" && !!object && object.constructor === Object;
+	return typeof object === "object" && !!object && object.constructor === Object;
 }
-var safeNativeProperties = {
-  length: true,
-  name: true
+const safeNativeProperties = {
+	length: true,
+	name: true
 };
-var safeNativeMethods = {
-  toString: true,
-  valueOf: true,
-  toLocaleString: true
+const safeNativeMethods = {
+	toString: true,
+	valueOf: true,
+	toLocaleString: true
 };
-
-// src/map.ts
+//#endregion
+//#region src/map.ts
 var ObjectWrappingMap = class {
-  wrappedObject;
-  [Symbol.toStringTag] = "ObjectWrappingMap";
-  constructor(object) {
-    this.wrappedObject = object;
-  }
-  /**
-   * Declared as a real method rather than assigned in the constructor through a
-   * cast. The old form satisfied the runtime but never appeared in the emitted
-   * type, so `implements Map<K, V>` was a lie that only surfaced downstream:
-   * consumers compiling with `skipLibCheck: false` got TS2420 ("incorrectly
-   * implements interface 'Map'... '[Symbol.iterator]' is missing").
-   */
-  [Symbol.iterator]() {
-    return this.entries();
-  }
-  keys() {
-    return Object.keys(this.wrappedObject).filter((key) => this.has(key)).values();
-  }
-  get(key) {
-    return getSafeProperty(this.wrappedObject, key);
-  }
-  set(key, value) {
-    setSafeProperty(this.wrappedObject, key, value);
-    return this;
-  }
-  has(key) {
-    return isSafeProperty(this.wrappedObject, key) && key in this.wrappedObject;
-  }
-  /**
-   * Return the value for `key`; when the key is absent, set it to `defaultValue` first.
-   * Declared because the ESNext `Map` (TC39 upsert) has it, and `implements Map` requires it.
-   */
-  getOrInsert(key, defaultValue) {
-    if (!this.has(key)) this.set(key, defaultValue);
-    return this.get(key);
-  }
-  /**
-   * Return the value for `key`; when the key is absent, set it to `callback(key)` first.
-   * Declared because the ESNext `Map` (TC39 upsert) has it, and `implements Map` requires it.
-   */
-  getOrInsertComputed(key, callback) {
-    if (!this.has(key)) this.set(key, callback(key));
-    return this.get(key);
-  }
-  entries() {
-    return mapIterator(this.keys(), (key) => [key, this.get(key)]);
-  }
-  *values() {
-    for (const key of this.keys()) {
-      yield this.get(key);
-    }
-  }
-  forEach(callback) {
-    for (const key of this.keys()) {
-      callback(this.get(key), key, this);
-    }
-  }
-  delete(key) {
-    if (isSafeProperty(this.wrappedObject, key)) {
-      delete this.wrappedObject[key];
-      return true;
-    }
-    return false;
-  }
-  clear() {
-    for (const key of this.keys()) {
-      this.delete(key);
-    }
-  }
-  get size() {
-    return Object.keys(this.wrappedObject).length;
-  }
+	wrappedObject;
+	[Symbol.toStringTag] = "ObjectWrappingMap";
+	constructor(object) {
+		this.wrappedObject = object;
+	}
+	[Symbol.iterator]() {
+		return this.entries();
+	}
+	keys() {
+		return Object.keys(this.wrappedObject).filter((key) => this.has(key)).values();
+	}
+	get(key) {
+		return getSafeProperty(this.wrappedObject, key);
+	}
+	set(key, value) {
+		setSafeProperty(this.wrappedObject, key, value);
+		return this;
+	}
+	has(key) {
+		return isSafeProperty(this.wrappedObject, key) && key in this.wrappedObject;
+	}
+	getOrInsert(key, defaultValue) {
+		if (!this.has(key)) this.set(key, defaultValue);
+		return this.get(key);
+	}
+	getOrInsertComputed(key, callback) {
+		if (!this.has(key)) this.set(key, callback(key));
+		return this.get(key);
+	}
+	entries() {
+		return mapIterator(this.keys(), (key) => [key, this.get(key)]);
+	}
+	*values() {
+		for (const key of this.keys()) yield this.get(key);
+	}
+	forEach(callback) {
+		for (const key of this.keys()) callback(this.get(key), key, this);
+	}
+	delete(key) {
+		if (isSafeProperty(this.wrappedObject, key)) {
+			delete this.wrappedObject[key];
+			return true;
+		}
+		return false;
+	}
+	clear() {
+		for (const key of this.keys()) this.delete(key);
+	}
+	get size() {
+		return Object.keys(this.wrappedObject).length;
+	}
 };
 var PartitionedMap = class {
-  a;
-  b;
-  bKeys;
-  [Symbol.toStringTag] = "PartitionedMap";
-  /**
-   * Create a PartitionedMap over two maps.
-   *
-   * @param a - Primary map
-   * @param b - Secondary map
-   * @param bKeys - Set of keys that should be read/written to map b
-   */
-  constructor(a, b, bKeys) {
-    this.a = a;
-    this.b = b;
-    this.bKeys = bKeys;
-  }
-  /** See the note on `ObjectWrappingMap[Symbol.iterator]` — same fix. */
-  [Symbol.iterator]() {
-    return this.entries();
-  }
-  get(key) {
-    return this.bKeys.has(key) ? this.b.get(key) : this.a.get(key);
-  }
-  set(key, value) {
-    if (this.bKeys.has(key)) {
-      this.b.set(key, value);
-    } else {
-      this.a.set(key, value);
-    }
-    return this;
-  }
-  has(key) {
-    return this.b.has(key) || this.a.has(key);
-  }
-  /**
-   * Return the value for `key`; when the key is absent, set it to `defaultValue` first.
-   * Declared because the ESNext `Map` (TC39 upsert) has it, and `implements Map` requires it.
-   */
-  getOrInsert(key, defaultValue) {
-    if (!this.has(key)) this.set(key, defaultValue);
-    return this.get(key);
-  }
-  /**
-   * Return the value for `key`; when the key is absent, set it to `callback(key)` first.
-   * Declared because the ESNext `Map` (TC39 upsert) has it, and `implements Map` requires it.
-   */
-  getOrInsertComputed(key, callback) {
-    if (!this.has(key)) this.set(key, callback(key));
-    return this.get(key);
-  }
-  keys() {
-    return (/* @__PURE__ */ new Set([...this.a.keys(), ...this.b.keys()]))[Symbol.iterator]();
-  }
-  *values() {
-    for (const key of this.keys()) {
-      yield this.get(key);
-    }
-  }
-  entries() {
-    return mapIterator(this.keys(), (key) => [key, this.get(key)]);
-  }
-  forEach(callback) {
-    for (const key of this.keys()) {
-      callback(this.get(key), key, this);
-    }
-  }
-  delete(key) {
-    return this.bKeys.has(key) ? this.b.delete(key) : this.a.delete(key);
-  }
-  clear() {
-    this.a.clear();
-    this.b.clear();
-  }
-  get size() {
-    return [...this.keys()].length;
-  }
+	a;
+	b;
+	bKeys;
+	[Symbol.toStringTag] = "PartitionedMap";
+	constructor(a, b, bKeys) {
+		this.a = a;
+		this.b = b;
+		this.bKeys = bKeys;
+	}
+	[Symbol.iterator]() {
+		return this.entries();
+	}
+	get(key) {
+		return this.bKeys.has(key) ? this.b.get(key) : this.a.get(key);
+	}
+	set(key, value) {
+		if (this.bKeys.has(key)) this.b.set(key, value);
+		else this.a.set(key, value);
+		return this;
+	}
+	has(key) {
+		return this.b.has(key) || this.a.has(key);
+	}
+	getOrInsert(key, defaultValue) {
+		if (!this.has(key)) this.set(key, defaultValue);
+		return this.get(key);
+	}
+	getOrInsertComputed(key, callback) {
+		if (!this.has(key)) this.set(key, callback(key));
+		return this.get(key);
+	}
+	keys() {
+		return (/* @__PURE__ */ new Set([...this.a.keys(), ...this.b.keys()]))[Symbol.iterator]();
+	}
+	*values() {
+		for (const key of this.keys()) yield this.get(key);
+	}
+	entries() {
+		return mapIterator(this.keys(), (key) => [key, this.get(key)]);
+	}
+	forEach(callback) {
+		for (const key of this.keys()) callback(this.get(key), key, this);
+	}
+	delete(key) {
+		return this.bKeys.has(key) ? this.b.delete(key) : this.a.delete(key);
+	}
+	clear() {
+		this.a.clear();
+		this.b.clear();
+	}
+	get size() {
+		return [...this.keys()].length;
+	}
 };
 function* mapIterator(it, callback) {
-  for (const value of it) yield callback(value);
-  return void 0;
+	for (const value of it) yield callback(value);
 }
 function createEmptyMap() {
-  return /* @__PURE__ */ new Map();
+	return /* @__PURE__ */ new Map();
 }
 function createMap(mapOrObject) {
-  if (!mapOrObject) {
-    return createEmptyMap();
-  }
-  if (isMap(mapOrObject)) {
-    return mapOrObject;
-  }
-  if (isObject(mapOrObject)) {
-    return new ObjectWrappingMap(mapOrObject);
-  }
-  throw new Error("createMap can create maps from objects or Maps");
-}
-function toObject(map2) {
-  if (map2 instanceof ObjectWrappingMap) {
-    return map2.wrappedObject;
-  }
-  const object = {};
-  for (const key of map2.keys()) {
-    const value = map2.get(key);
-    setSafeProperty(object, key, value);
-  }
-  return object;
-}
-function assign(map2, ...objects) {
-  for (const args of objects) {
-    if (!args) {
-      continue;
-    }
-    if (isMap(args)) {
-      for (const key of args.keys()) {
-        map2.set(key, args.get(key));
-      }
-    } else if (isObject(args)) {
-      for (const key of Object.keys(args)) {
-        map2.set(key, args[key]);
-      }
-    }
-  }
-  return map2;
+	if (!mapOrObject) return createEmptyMap();
+	if (isMap(mapOrObject)) return mapOrObject;
+	if (isObject(mapOrObject)) return new ObjectWrappingMap(mapOrObject);
+	throw new Error("createMap can create maps from objects or Maps");
+}
+function toObject(map) {
+	if (map instanceof ObjectWrappingMap) return map.wrappedObject;
+	const object = {};
+	for (const key of map.keys()) setSafeProperty(object, key, map.get(key));
+	return object;
+}
+function assign(map, ...objects) {
+	for (const args of objects) {
+		if (!args) continue;
+		if (isMap(args)) for (const key of args.keys()) map.set(key, args.get(key));
+		else if (isObject(args)) for (const key of Object.keys(args)) map.set(key, args[key]);
+	}
+	return map;
 }
 function isObjectWrappingMap(object) {
-  if (!isMap(object)) return false;
-  const wrapper = object;
-  return isObject(wrapper.wrappedObject);
+	if (!isMap(object)) return false;
+	return isObject(object.wrappedObject);
 }
-
-// src/wasm-loader.ts
-var ALGO = "sha384";
+//#endregion
+//#region src/wasm-loader.ts
+const ALGO = "sha384";
 async function sha384OfBuffer(buffer) {
-  const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
-  const isNode = typeof process !== "undefined" && process.versions?.node !== void 0;
-  let digest;
-  if (isNode) {
-    const { createHash } = await import("crypto");
-    const hash = createHash(ALGO);
-    hash.update(bytes);
-    digest = new Uint8Array(hash.digest());
-  } else {
-    const copy = new ArrayBuffer(bytes.byteLength);
-    new Uint8Array(copy).set(bytes);
-    const out = await crypto.subtle.digest("SHA-384", copy);
-    digest = new Uint8Array(out);
-  }
-  let binary = "";
-  for (let i = 0; i < digest.length; i++) binary += String.fromCharCode(digest[i]);
-  const b64 = typeof btoa === "function" ? btoa(binary) : Buffer.from(digest).toString("base64");
-  return `sha384-${b64}`;
+	const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+	const isNode = typeof process !== "undefined" && process.versions?.node !== void 0;
+	let digest;
+	if (isNode) {
+		const { createHash } = await import("crypto");
+		const hash = createHash(ALGO);
+		hash.update(bytes);
+		digest = new Uint8Array(hash.digest());
+	} else {
+		const copy = new ArrayBuffer(bytes.byteLength);
+		new Uint8Array(copy).set(bytes);
+		const out = await crypto.subtle.digest("SHA-384", copy);
+		digest = new Uint8Array(out);
+	}
+	let binary = "";
+	for (let i = 0; i < digest.length; i++) binary += String.fromCharCode(digest[i]);
+	return `sha384-${typeof btoa === "function" ? btoa(binary) : Buffer.from(digest).toString("base64")}`;
 }
 async function loadWasmManifest(wasmPath) {
-  const isNode = typeof process !== "undefined" && process.versions?.node !== void 0;
-  const manifestPath = wasmPath.replace(/[^/\\]+$/, "wasm-manifest.json");
-  try {
-    if (isNode) {
-      const fs = await import("fs");
-      const { promisify } = await import("util");
-      const readFile = promisify(fs.readFile);
-      const text = await readFile(manifestPath, "utf8");
-      return JSON.parse(text);
-    } else {
-      const res = await fetch(manifestPath);
-      if (!res.ok) return null;
-      return await res.json();
-    }
-  } catch {
-    return null;
-  }
+	const isNode = typeof process !== "undefined" && process.versions?.node !== void 0;
+	const manifestPath = wasmPath.replace(/[^/\\]+$/, "wasm-manifest.json");
+	try {
+		if (isNode) {
+			const fs = await import("fs");
+			const { promisify } = await import("util");
+			const text = await promisify(fs.readFile)(manifestPath, "utf8");
+			return JSON.parse(text);
+		} else {
+			const res = await fetch(manifestPath);
+			if (!res.ok) return null;
+			return await res.json();
+		}
+	} catch {
+		return null;
+	}
 }
 async function verifyWasmIntegrity(buffer, wasmPath, options = {}) {
-  const fileName = wasmPath.split(/[/\\]/).pop() || wasmPath;
-  const manifest = options.manifest !== void 0 ? options.manifest : await loadWasmManifest(wasmPath);
-  if (!manifest) {
-    if (options.required) {
-      throw new Error(
-        `WASM integrity check failed: no manifest at sibling of "${wasmPath}" (required)`
-      );
-    }
-    if (typeof console !== "undefined") {
-      console.warn(
-        `[wasm-integrity] no manifest found beside "${wasmPath}"; skipping SHA-384 verification (set options.required=true to fail closed)`
-      );
-    }
-    return;
-  }
-  const expected = manifest[fileName];
-  if (!expected) {
-    if (options.required) {
-      throw new Error(`WASM integrity check failed: manifest has no entry for "${fileName}"`);
-    }
-    return;
-  }
-  const actual = await sha384OfBuffer(buffer);
-  if (actual !== expected) {
-    throw new Error(
-      `WASM integrity check failed for "${fileName}": expected ${expected}, got ${actual}`
-    );
-  }
+	const fileName = wasmPath.split(/[/\\]/).pop() || wasmPath;
+	const manifest = options.manifest !== void 0 ? options.manifest : await loadWasmManifest(wasmPath);
+	if (!manifest) {
+		if (options.required) throw new Error(`WASM integrity check failed: no manifest at sibling of "${wasmPath}" (required)`);
+		if (typeof console !== "undefined") console.warn(`[wasm-integrity] no manifest found beside "${wasmPath}"; skipping SHA-384 verification (set options.required=true to fail closed)`);
+		return;
+	}
+	const expected = manifest[fileName];
+	if (!expected) {
+		if (options.required) throw new Error(`WASM integrity check failed: manifest has no entry for "${fileName}"`);
+		return;
+	}
+	const actual = await sha384OfBuffer(buffer);
+	if (actual !== expected) throw new Error(`WASM integrity check failed for "${fileName}": expected ${expected}, got ${actual}`);
 }
 async function resolvePackagedWasm(metaUrl, wasmFile) {
-  const isNode = typeof process !== "undefined" && process.versions?.node !== void 0;
-  if (!isNode) return null;
-  const { fileURLToPath } = await import("url");
-  const { dirname, join: join2 } = await import("path");
-  const { existsSync } = await import("fs");
-  let dir = dirname(fileURLToPath(metaUrl));
-  for (let depth = 0; depth < 8; depth++) {
-    const candidates = [join2(dir, "wasm", wasmFile), join2(dir, "dist", "wasm", wasmFile)];
-    for (const candidate of candidates) {
-      if (existsSync(candidate)) return candidate;
-    }
-    const parent = dirname(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  return null;
+	if (!(typeof process !== "undefined" && process.versions?.node !== void 0)) return null;
+	const { fileURLToPath } = await import("node:url");
+	const { dirname, join } = await import("node:path");
+	const { existsSync } = await import("node:fs");
+	let dir = dirname(fileURLToPath(metaUrl));
+	for (let depth = 0; depth < 8; depth++) {
+		const candidates = [join(dir, "wasm", wasmFile), join(dir, "dist", "wasm", wasmFile)];
+		for (const candidate of candidates) if (existsSync(candidate)) return candidate;
+		const parent = dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return null;
 }
 async function defaultWasmLocation(metaUrl, wasmFile, opts) {
-  if (opts?.browser) {
-    return new URL(`./wasm/${wasmFile}`, metaUrl).href;
-  }
-  const { fileURLToPath } = await import("url");
-  const { dirname, join: join2 } = await import("path");
-  const { existsSync } = await import("fs");
-  let dir = dirname(fileURLToPath(metaUrl));
-  for (let depth = 0; depth < 8; depth++) {
-    if (existsSync(join2(dir, "package.json"))) {
-      return join2(dir, "dist", "wasm", wasmFile);
-    }
-    const parent = dirname(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  return join2(dirname(fileURLToPath(metaUrl)), "wasm", wasmFile);
-}
-export {
-  Unit as CoreUnit,
-  DEFAULT_CONFIG,
-  DimensionError,
-  IndexError,
-  MathjsError,
-  ObjectWrappingMap,
-  PartitionedMap,
-  _switch,
-  acosh,
-  arraySize,
-  asinh,
-  assertDependencies,
-  assign as assignMap,
-  atanh,
-  broadcastArrays,
-  broadcastSizes,
-  broadcastTo,
-  canDefineProperty,
-  cbrt,
-  checkBroadcastingRules,
-  clone,
-  clone2 as cloneArray,
-  compareText,
-  concat,
-  containsCollections,
-  copysign,
-  cosh,
-  create,
-  createEmptyMap,
-  createIndexError,
-  createMap,
-  createUnitClass,
-  deepExtend,
-  deepFlatten,
-  deepForEach2 as deepForEach,
-  deepForEach as deepForEachArray,
-  deepMap2 as deepMap,
-  deepMap as deepMapArray,
-  deepStrictEqual,
-  defaultWasmLocation,
-  digits,
-  endsWith,
-  escape,
-  expm1,
-  extend,
-  factory,
-  filter,
-  filterRegExp,
-  flatten,
-  forEach,
-  format,
-  format2 as formatBigNumber,
-  format3 as formatGeneric,
-  generalize,
-  get,
-  getArrayDataType,
-  get2 as getArrayElement,
-  hasOwnProperty,
-  identify,
-  initial,
-  isArray,
-  isBigInt,
-  isBigNumber,
-  isBoolean,
-  isCollection,
-  isComplex,
-  isDate,
-  isDenseMatrix,
-  isEmptyIndex,
-  isFactory,
-  isFraction,
-  isFunction,
-  isIndex,
-  isInteger,
-  isLegacyFactory,
-  isMap,
-  isMatrix,
-  isNull,
-  isNumber,
-  isObject,
-  isObjectWrappingMap,
-  isOptionalDependency,
-  isPowZeroAtInfinity,
-  isRange,
-  isRegExp,
-  isSparseMatrix,
-  isString,
-  isUndefined,
-  isUnit,
-  join,
-  last,
-  lazy,
-  loadWasmManifest,
-  log10,
-  log1p,
-  log2,
-  map,
-  mapObject,
-  memoize,
-  nearlyEqual,
-  normalizeFormatOptions,
-  pick,
-  pickShallow,
-  processSizesWildcard,
-  reduce,
-  reshape,
-  resize,
-  resolvePackagedWasm,
-  roundDigits,
-  safeNumberType,
-  scatter,
-  set,
-  sha384OfBuffer,
-  sign,
-  sinh,
-  sortFactories,
-  splitNumber,
-  squeeze,
-  stretch,
-  stringify,
-  stripOptionalNotation,
-  tanh,
-  toEngineering,
-  toEngineering2 as toEngineeringBigNumber,
-  toExponential,
-  toExponential2 as toExponentialBigNumber,
-  toFixed,
-  toFixed2 as toFixedBigNumber,
-  toObject,
-  toPrecision,
-  traverse,
-  typeOf,
-  unitDependencies,
-  unsqueeze,
-  validate,
-  validateIndex,
-  validateIndexSourceSize,
-  verifyWasmIntegrity,
-  warnOnce
+	if (opts?.browser) return new URL(`./wasm/${wasmFile}`, metaUrl).href;
+	const { fileURLToPath } = await import("node:url");
+	const { dirname, join } = await import("node:path");
+	const { existsSync } = await import("node:fs");
+	let dir = dirname(fileURLToPath(metaUrl));
+	for (let depth = 0; depth < 8; depth++) {
+		if (existsSync(join(dir, "package.json"))) return join(dir, "dist", "wasm", wasmFile);
+		const parent = dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return join(dirname(fileURLToPath(metaUrl)), "wasm", wasmFile);
+}
+var WasmModuleLoader = class {
+	wasmModule = null;
+	compiledModule = null;
+	loading = null;
+	isNode;
+	lastMetrics = null;
+	constructor() {
+		this.isNode = typeof process !== "undefined" && process.versions?.node !== void 0;
+	}
+	async load(wasmPath) {
+		if (this.wasmModule) return this.wasmModule;
+		if (this.loading) return this.loading;
+		this.loading = this.loadModule(wasmPath);
+		try {
+			this.wasmModule = await this.loading;
+		} catch (error) {
+			this.compiledModule = null;
+			throw error;
+		} finally {
+			this.loading = null;
+		}
+		return this.wasmModule;
+	}
+	async loadModule(wasmPath) {
+		const path = wasmPath || await this.getDefaultWasmPath();
+		const totalStart = performance.now();
+		if (this.compiledModule) {
+			const instStart = performance.now();
+			const instance = await WebAssembly.instantiate(this.compiledModule, this.getImports());
+			this.lastMetrics = {
+				fileReadMs: 0,
+				compileMs: 0,
+				instantiateMs: performance.now() - instStart,
+				totalMs: performance.now() - totalStart,
+				fromCache: true
+			};
+			return instance.exports;
+		}
+		if (this.isNode) return this.loadNodeWasm(path, totalStart);
+		return this.loadBrowserWasm(path, totalStart);
+	}
+	async precompile(wasmPath) {
+		if (this.compiledModule) return;
+		const path = wasmPath || await this.getDefaultWasmPath();
+		const startTime = performance.now();
+		if (this.isNode) {
+			const fs = await import("fs");
+			const { promisify } = await import("util");
+			const buffer = await promisify(fs.readFile)(path);
+			await verifyWasmIntegrity(buffer, path);
+			this.compiledModule = await WebAssembly.compile(buffer);
+		} else {
+			const manifest = await loadWasmManifest(path);
+			if (!manifest && typeof WebAssembly.compileStreaming === "function") this.compiledModule = await WebAssembly.compileStreaming(fetch(path));
+			else {
+				const buffer = await (await fetch(path)).arrayBuffer();
+				await verifyWasmIntegrity(buffer, path, { manifest });
+				this.compiledModule = await WebAssembly.compile(buffer);
+			}
+		}
+		this.lastMetrics = {
+			fileReadMs: 0,
+			compileMs: performance.now() - startTime,
+			instantiateMs: 0,
+			totalMs: performance.now() - startTime,
+			fromCache: false
+		};
+	}
+	async loadNodeWasm(path, totalStart) {
+		const fs = await import("fs");
+		const { promisify } = await import("util");
+		const readFile = promisify(fs.readFile);
+		const readStart = performance.now();
+		const buffer = await readFile(path);
+		const readEnd = performance.now();
+		await verifyWasmIntegrity(buffer, path);
+		const compileStart = performance.now();
+		this.compiledModule = await WebAssembly.compile(buffer);
+		const compileEnd = performance.now();
+		const instStart = performance.now();
+		const instance = await WebAssembly.instantiate(this.compiledModule, this.getImports());
+		const instEnd = performance.now();
+		this.lastMetrics = {
+			fileReadMs: readEnd - readStart,
+			compileMs: compileEnd - compileStart,
+			instantiateMs: instEnd - instStart,
+			totalMs: performance.now() - totalStart,
+			fromCache: false
+		};
+		return instance.exports;
+	}
+	async loadBrowserWasm(path, totalStart) {
+		const manifest = await loadWasmManifest(path);
+		if (!manifest && typeof WebAssembly.instantiateStreaming === "function") {
+			const instStart = performance.now();
+			const result = await WebAssembly.instantiateStreaming(fetch(path), this.getImports());
+			this.compiledModule = result.module;
+			this.lastMetrics = {
+				fileReadMs: 0,
+				compileMs: 0,
+				instantiateMs: performance.now() - instStart,
+				totalMs: performance.now() - totalStart,
+				fromCache: false
+			};
+			return result.instance.exports;
+		}
+		const readStart = performance.now();
+		const buffer = await (await fetch(path)).arrayBuffer();
+		const readEnd = performance.now();
+		await verifyWasmIntegrity(buffer, path, { manifest });
+		const compileStart = performance.now();
+		this.compiledModule = await WebAssembly.compile(buffer);
+		const compileEnd = performance.now();
+		const instStart = performance.now();
+		const instance = await WebAssembly.instantiate(this.compiledModule, this.getImports());
+		const instEnd = performance.now();
+		this.lastMetrics = {
+			fileReadMs: readEnd - readStart,
+			compileMs: compileEnd - compileStart,
+			instantiateMs: instEnd - instStart,
+			totalMs: performance.now() - totalStart,
+			fromCache: false
+		};
+		return instance.exports;
+	}
+	getImports() {
+		return {
+			env: {
+				abort: (msg, file, line, column) => {
+					console.error("WASM abort", {
+						msg,
+						file,
+						line,
+						column
+					});
+					throw new Error("WASM abort");
+				},
+				seed: () => Date.now()
+			},
+			Math,
+			Date
+		};
+	}
 };
+//#endregion
+//#region src/wasm-as-header.ts
+function allocAsHeader(mod, byteLength, typeId) {
+	const bufferPtr = mod.__pin(mod.__new(byteLength, 1)) >>> 0;
+	const headerPtr = mod.__new(12, typeId) >>> 0;
+	mod.__pin(headerPtr);
+	const dv = new DataView(mod.memory.buffer);
+	dv.setUint32(headerPtr + 0, bufferPtr, true);
+	dv.setUint32(headerPtr + 4, bufferPtr, true);
+	dv.setUint32(headerPtr + 8, byteLength, true);
+	return {
+		headerPtr,
+		bufferPtr
+	};
+}
+//#endregion
+export { Unit as CoreUnit, DEFAULT_CONFIG, DimensionError, IndexError, MathjsError, ObjectWrappingMap, PartitionedMap, WasmModuleLoader, _switch, acosh, allocAsHeader, arraySize, asinh, assertDependencies, assign as assignMap, atanh, broadcastArrays, broadcastSizes, broadcastTo, canDefineProperty, cbrt, checkBroadcastingRules, clone, clone$1 as cloneArray, compareText, concat, containsCollections, copysign, cosh, create, createEmptyMap, createIndexError, createMap, createUnitClass, deepExtend, deepFlatten, deepForEach, deepForEach$1 as deepForEachArray, deepMap, deepMap$1 as deepMapArray, deepStrictEqual, defaultWasmLocation, digits, endsWith, escape, expm1, extend, factory, filter, filterRegExp, flatten, forEach, format, format$1 as formatBigNumber, format$2 as formatGeneric, generalize, get, getArrayDataType, get$1 as getArrayElement, hasOwnProperty, identify, initial, isArray, isBigInt, isBigNumber, isBoolean, isCollection, isComplex, isDate, isDenseMatrix, isEmptyIndex, isFactory, isFraction, isFunction, isIndex, isInteger, isLegacyFactory, isMap, isMatrix, isNull, isNumber, isObject, isObjectWrappingMap, isOptionalDependency, isPowZeroAtInfinity, isRange, isRegExp, isSparseMatrix, isString, isUndefined, isUnit, join, last, lazy, loadWasmManifest, log10, log1p, log2, map, mapObject, memoize, nearlyEqual, normalizeFormatOptions, pick, pickShallow, processSizesWildcard, reduce, reshape, resize, resolvePackagedWasm, roundDigits, safeNumberType, scatter, set, sha384OfBuffer, sign, sinh, sortFactories, splitNumber, squeeze, stretch, stringify, stripOptionalNotation, tanh, toEngineering, toEngineering$1 as toEngineeringBigNumber, toExponential, toExponential$1 as toExponentialBigNumber, toFixed, toFixed$1 as toFixedBigNumber, toObject, toPrecision, traverse, typeOf, unitDependencies, unsqueeze, validate, validateIndex, validateIndexSourceSize, verifyWasmIntegrity, warnOnce };