@danielsimonjr/mathts-core 0.9.0 → 0.11.0

package/dist/internal.js

@@ -1,13 +1,16 @@
 import {
+  MathjsError,
   Unit,
   acosh,
   asinh,
+  assertDependencies,
   atanh,
   canDefineProperty,
   cbrt,
   clone,
   copysign,
   cosh,
+  create,
   createUnitClass,
   deepExtend,
   deepFlatten,
@@ -16,6 +19,7 @@ import {
   endsWith,
   expm1,
   extend,
+  factory,
   format,
   get,
   hasOwnProperty,
@@ -27,6 +31,7 @@ import {
   isComplex2 as isComplex,
   isDate,
   isDenseMatrix,
+  isFactory,
   isFraction,
   isFunction,
   isIndex,
@@ -37,6 +42,7 @@ import {
   isNull,
   isNumber,
   isObject,
+  isOptionalDependency,
   isPowZeroAtInfinity,
   isRange,
   isRegExp,
@@ -59,7 +65,9 @@ import {
   set,
   sign,
   sinh,
+  sortFactories,
   splitNumber,
+  stripOptionalNotation,
   tanh,
   toEngineering,
   toExponential,
@@ -69,28 +77,1338 @@ import {
   typeOf,
   unitDependencies,
   warnOnce
-} from "./chunk-2WW76EEF.js";
+} from "./chunk-PALIR4V6.js";
+
+// src/error/DimensionError.ts
+var DimensionError = class _DimensionError extends RangeError {
+  actual;
+  expected;
+  relation;
+  isDimensionError = true;
+  /**
+   * @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);
+    }
+  }
+};
+
+// 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);
+    }
+  }
+};
+function createIndexError(index, min, max) {
+  return new IndexError(index, min, max);
+}
+
+// src/bignumber-formatter.ts
+function formatBigNumberToBase(n, base, size) {
+  const BigNumberCtor = n.constructor;
+  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 = _toNumberOrDefault(optionsObj?.lowerExp, -3);
+      const upperExp = _toNumberOrDefault(optionsObj?.upperExp, 5);
+      if (v.isZero()) return "0";
+      let str;
+      const rounded = v.toSignificantDigits(precision);
+      const exp = rounded.e;
+      if (exp >= lowerExp && exp < upperExp) {
+        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 = value.constructor;
+    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);
+}
+function _toNumberOrDefault(value, defaultValue) {
+  if (isNumber(value)) {
+    return value;
+  } else if (isBigNumber(value)) {
+    return value.toNumber();
+  } else {
+    return defaultValue;
+  }
+}
+
+// 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;
+}
+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);
+}
+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"
+};
+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;
+}
+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);
+  }
+}
+function looksLikeFraction(value) {
+  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
+function arraySize(x) {
+  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, ">");
+      }
+    }
+  }
+}
+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);
+  }
+}
+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]);
+    }
+  });
+}
+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);
+    }
+  }
+}
+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;
+}
+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;
+}
+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;
+    }
+  }
+}
+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) {
+      throw new DimensionError(newLength, currentLength, "!=");
+    }
+    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;
+}
+function product(array) {
+  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;
+}
+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;
+}
+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;
+  }
+}
+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;
+}
+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;
+  }
+}
+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]);
+      }
+    }
+  }
+}
+function map(array, callback) {
+  return Array.prototype.map.call(array, callback);
+}
+function forEach(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);
+}
+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));
+}
+function join(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;
+}
+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;
+}
+function last(array) {
+  return array[array.length - 1];
+}
+function initial(array) {
+  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);
+  }
+}
+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");
+  }
+}
+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;
+}
+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]}`
+      );
+    }
+  }
+}
+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;
+}
+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;
+}
+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
+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
+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);
+  }
+}
+function reduce(mat, dim, callback) {
+  const size = Array.isArray(mat) ? arraySize(mat) : mat.size();
+  if (dim < 0 || dim >= size.length) {
+    throw new IndexError(dim, 0, 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;
+  }
+}
+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
+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 + '"');
+}
+function setSafeProperty(object, prop, value) {
+  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;
+}
+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;
+}
+function isPlainObject(object) {
+  return typeof object === "object" && !!object && object.constructor === Object;
+}
+var safeNativeProperties = {
+  length: true,
+  name: true
+};
+var safeNativeMethods = {
+  toString: true,
+  valueOf: true,
+  toLocaleString: true
+};
+
+// 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();
+  }
+  // @ts-expect-error: Implementation is compatible but TS can't infer it
+  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;
+  }
+  // @ts-expect-error: Implementation is compatible but TS can't infer it
+  entries() {
+    return mapIterator(this.keys(), (key) => [key, this.get(key)]);
+  }
+  // @ts-expect-error: Implementation is compatible but TS can't infer it
+  *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";
+  /**
+   * @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);
+  }
+  // @ts-expect-error: Implementation is compatible but TS can't infer it
+  keys() {
+    return (/* @__PURE__ */ new Set([...this.a.keys(), ...this.b.keys()]))[Symbol.iterator]();
+  }
+  // @ts-expect-error: Implementation is compatible but TS can't infer it
+  *values() {
+    for (const key of this.keys()) {
+      yield this.get(key);
+    }
+  }
+  // @ts-expect-error: Implementation is compatible but TS can't infer it
+  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) {
+  return {
+    next: () => {
+      const n = it.next();
+      return n.done ? n : {
+        value: callback(n.value),
+        done: false
+      };
+    }
+  };
+}
+function createEmptyMap() {
+  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;
+}
+function isObjectWrappingMap(object) {
+  if (!isMap(object)) return false;
+  const wrapper = object;
+  return isObject(wrapper.wrappedObject);
+}
 export {
   Unit as CoreUnit,
+  DimensionError,
+  IndexError,
+  MathjsError,
+  ObjectWrappingMap,
+  PartitionedMap,
   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,
   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,
@@ -99,6 +1417,8 @@ export {
   isComplex,
   isDate,
   isDenseMatrix,
+  isEmptyIndex,
+  isFactory,
   isFraction,
   isFunction,
   isIndex,
@@ -109,6 +1429,8 @@ export {
   isNull,
   isNumber,
   isObject,
+  isObjectWrappingMap,
+  isOptionalDependency,
   isPowZeroAtInfinity,
   isRange,
   isRegExp,
@@ -116,29 +1438,50 @@ export {
   isString,
   isUndefined,
   isUnit,
+  join,
+  last,
   lazy,
   log10,
   log1p,
   log2,
+  map,
   mapObject,
   memoize,
   nearlyEqual,
   normalizeFormatOptions,
   pick,
   pickShallow,
+  processSizesWildcard,
+  reduce,
+  reshape,
+  resize,
   roundDigits,
   safeNumberType,
+  scatter,
   set,
   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,
   warnOnce
 };