@danielsimonjr/mathts-expression 0.6.3 → 0.6.5

package/dist/index.d.ts

@@ -70,6 +70,40 @@ declare function isAssociativeWith(nodeA: unknown, nodeB: unknown, parenthesis:
  */
 declare function getOperator(fn: string): string | null;
 
+/**
+ * Some of this file's helpers are consolidated onto core (see the re-exports at
+ * the bottom): `isFactory`, `assertDependencies`, `isOptionalDependency`,
+ * `stripOptionalNotation`, and the plain-data types `LegacyFactory`/`FactoryMeta`/
+ * `DependencyName` are byte-for-byte equivalent to
+ * `@danielsimonjr/mathts-core/internal`'s copies (proven via a fast-check property
+ * harness — see `functions/tests/dedup-bucketB-equivalence.test.ts`) and are
+ * re-exported from there.
+ *
+ * `factory`/`FactoryFunction`/`CreateFunction` remain DELIBERATELY KEPT LOCAL — NOT
+ * safe to redirect: `factory()`'s generic `CreateFunction<TDeps extends
+ * Record<string, unknown>, ...>` constraint (core's copy) rejects real call sites
+ * across this package (and `functions`) whose destructured dependency objects are
+ * typed as plain interfaces without an index signature — confirmed empirically:
+ * redirecting it broke `tsc --noEmit` with dozens of TS2345 errors. This mirrors the
+ * `functions` package's pre-existing `@typescript-eslint/no-explicit-any`
+ * workaround comment on its own local `CreateFunction`, which independently
+ * documents the exact same constraint mismatch.
+ *
+ * `sortFactories`/`create` are now ADOPTED from core (Bucket B, commit 2): they
+ * don't depend on `factory()`'s generic constraint (they only operate on already-
+ * constructed `FactoryFunction`/`LegacyFactory` values), so they aren't blocked by
+ * the divergence above. Core's `sortFactories` throws on ANY circular dependency —
+ * direct or indirect (see `core/tests/factory-sort.test.ts`) — which is a
+ * deliberate fix over this file's FORMER local copy, which only special-cased
+ * direct 2-cycles and otherwise silently broke longer cycles via a visited-set
+ * guard without throwing (see `functions/tests/dedup-bucketB-equivalence.test.ts`'s
+ * former "PROVEN DIVERGENCE" block, now updated to reflect the adoption). Verified
+ * this package's real `factory()` call sites are never fed through `sortFactories`/
+ * `create` in production (both are otherwise-unused mathjs legacy machinery here —
+ * every real node/parse factory is wired by hand with an explicit dependency
+ * object, e.g. `expression/tests/helpers/bootstrap.ts`), so there is no live
+ * dependency graph that could hit the stricter throw.
+ */
 /**
  * Type for a factory function that creates instances
  */

package/dist/index.js

@@ -142,9 +142,6 @@ function isBigInt(x) {
 function isComplex(x) {
   return !!(x && typeof x === "object" && Object.getPrototypeOf(x).isComplex === true);
 }
-function isFraction(x) {
-  return !!(x && typeof x === "object" && Object.getPrototypeOf(x).isFraction === true);
-}
 function isUnit(x) {
   if (!x || typeof x !== "object") return false;
   const obj = x;
@@ -175,19 +172,6 @@ function isHelp(x) {
 function isFunction(x) {
   return typeof x === "function";
 }
-function isObject(x) {
-  return !!(x && typeof x === "object" && x.constructor === Object && !isComplex(x) && !isFraction(x));
-}
-function isMap(object) {
-  if (!object) {
-    return false;
-  }
-  if (object instanceof Map) {
-    return true;
-  }
-  const mapLike = object;
-  return typeof mapLike.set === "function" && typeof mapLike.get === "function" && typeof mapLike.keys === "function" && typeof mapLike.has === "function";
-}
 function isAccessorNode(x) {
   if (!x || typeof x !== "object") return false;
   const obj = x;
@@ -604,24 +588,15 @@ function getOperator(fn) {
   return null;
 }
 
-// src/error/MathjsError.ts
-var MathjsError = class _MathjsError extends Error {
-  isMathjsError = true;
-  /**
-   * Create a MathjsError
-   * @param message  Error message
-   */
-  constructor(message) {
-    super(message);
-    this.name = "MathjsError";
-    const { captureStackTrace } = Error;
-    if (captureStackTrace) {
-      captureStackTrace(this, _MathjsError);
-    }
-  }
-};
-
 // src/utils/factory.ts
+import {
+  isFactory,
+  assertDependencies,
+  isOptionalDependency,
+  stripOptionalNotation,
+  sortFactories as coreSortFactories,
+  create as coreCreate
+} from "@danielsimonjr/mathts-core/internal";
 function factory(name47, dependencies47, create, meta) {
   function assertAndCreate(scope) {
     const deps = pickShallow(scope, dependencies47.map(stripOptionalNotation));
@@ -636,70 +611,15 @@ function factory(name47, dependencies47, create, meta) {
   }
   return assertAndCreate;
 }
-function assertDependencies(name47, dependencies47, scope) {
-  const allDefined = dependencies47.filter((dependency) => !isOptionalDependency(dependency)).every((dependency) => scope[dependency] !== void 0);
-  if (!allDefined) {
-    const missingDependencies = dependencies47.filter(
-      (dependency) => scope[dependency] === void 0
-    );
-    throw new MathjsError(
-      `Cannot create function "${name47}", some dependencies are missing: ${missingDependencies.map((d) => `"${d}"`).join(", ")}.`
-    );
-  }
-}
-function isOptionalDependency(dependency) {
-  return Boolean(dependency && dependency[0] === "?");
-}
-function stripOptionalNotation(dependency) {
-  return dependency && dependency[0] === "?" ? dependency.slice(1) : dependency;
-}
 
-// 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 { captureStackTrace } = Error;
-    if (captureStackTrace) {
-      captureStackTrace(this, _IndexError);
-    }
-  }
-};
+// src/utils/collection.ts
+import {
+  containsCollections,
+  deepForEach,
+  deepMap,
+  reduce,
+  scatter
+} from "@danielsimonjr/mathts-core/internal";
 
 // src/utils/number.ts
 import {
@@ -730,283 +650,6 @@ import {
   toPrecision
 } from "@danielsimonjr/mathts-core/internal";
 
-// src/utils/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) {
-  if (typeof options === "function") {
-    return options(value);
-  }
-  if (!value.isFinite()) {
-    return value.isNaN() ? "NaN" : value.gt(0) ? "Infinity" : "-Infinity";
-  }
-  const { notation, precision, wordSize } = normalizeFormatOptions(options);
-  switch (notation) {
-    case "fixed":
-      return toFixed2(value, precision);
-    case "exponential":
-      return toExponential2(value, precision);
-    case "engineering":
-      return toEngineering2(value, precision);
-    case "bin":
-      return formatBigNumberToBase(value, 2, wordSize);
-    case "oct":
-      return formatBigNumberToBase(value, 8, wordSize);
-    case "hex":
-      return formatBigNumberToBase(value, 16, wordSize);
-    case "auto": {
-      const optionsObject = typeof options === "object" ? options : void 0;
-      const lowerExp = _toNumberOrDefault(optionsObject?.lowerExp, -3);
-      const upperExp = _toNumberOrDefault(optionsObject?.upperExp, 5);
-      if (value.isZero()) return "0";
-      let str;
-      const rounded = value.toSignificantDigits(precision);
-      const exp = rounded.e;
-      if (exp >= lowerExp && exp < upperExp) {
-        str = rounded.toFixed();
-      } else {
-        str = toExponential2(value, 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 BigNumber = value.constructor;
-    valueStr = new BigNumber(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/utils/string.ts
-function format3(value, options) {
-  const result = _format(value, options);
-  if (options && typeof options === "object" && "truncate" in options && result.length > options.truncate) {
-    return result.substring(0, options.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)) {
-    const v = value;
-    const opts = options;
-    if (!opts || opts.fraction !== "decimal") {
-      const signedNumerator = typeof v.n === "bigint" ? BigInt(v.s) * v.n : v.s * v.n;
-      return `${signedNumerator}/${v.d}`;
-    } else {
-      return v.toString();
-    }
-  }
-  if (Array.isArray(value)) {
-    return formatArray(value, options);
-  }
-  if (isString(value)) {
-    return stringify(value);
-  }
-  if (typeof value === "function") {
-    const fn = value;
-    return fn.syntax ? String(fn.syntax) : "function";
-  }
-  if (value && typeof value === "object") {
-    const v = value;
-    if (typeof v.format === "function") {
-      return v.format(options);
-    } else if (value && v.toString(options) !== {}.toString()) {
-      return v.toString(options);
-    } else {
-      const entries = Object.keys(value).map((key) => {
-        return stringify(key) + ": " + format3(value[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) {
-  return !!value && typeof value === "object" && typeof value.s === "bigint" && typeof value.n === "bigint" && typeof value.d === "bigint" || false;
-}
-
-// src/utils/array.ts
-function map(array, callback) {
-  return Array.prototype.map.call(array, callback);
-}
-function forEach(array, callback) {
-  Array.prototype.forEach.call(array, callback);
-}
-function join(array, separator) {
-  return Array.prototype.join.call(array, separator);
-}
-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);
-    }
-  }
-}
-
-// src/utils/collection.ts
-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);
-  }
-}
-
 // src/parse.ts
 var name = "parse";
 var dependencies = [
@@ -1067,7 +710,7 @@ var createParse = /* @__PURE__ */ factory(
     });
     function parseMultiple(expressions, options = {}) {
       const extraNodes = options.nodes !== void 0 ? options.nodes : {};
-      return deepMap2(
+      return deepMap(
         expressions,
         function(elem) {
           if (typeof elem !== "string") throw new TypeError("String expected");
@@ -1653,11 +1296,11 @@ var createParse = /* @__PURE__ */ factory(
     }
     function parseMultiplyDivideModulus(state) {
       let node;
-      let last;
+      let last2;
       let name47;
       let fn;
       node = parseImplicitMultiplication(state);
-      last = node;
+      last2 = node;
       const operators = {
         "*": "multiply",
         ".*": "dotMultiply",
@@ -1671,8 +1314,8 @@ var createParse = /* @__PURE__ */ factory(
           name47 = state.token;
           fn = operators[name47];
           getTokenSkipNewline(state);
-          last = parseImplicitMultiplication(state);
-          node = new OperatorNode(name47, fn, [node, last]);
+          last2 = parseImplicitMultiplication(state);
+          node = new OperatorNode(name47, fn, [node, last2]);
         } else {
           break;
         }
@@ -1681,16 +1324,16 @@ var createParse = /* @__PURE__ */ factory(
     }
     function parseImplicitMultiplication(state) {
       let node;
-      let last;
+      let last2;
       node = parseRule2(state);
-      last = node;
+      last2 = node;
       while (true) {
-        if (state.tokenType === 3 /* SYMBOL */ || state.token === "in" && isConstantNode(node) || state.token === "in" && isOperatorNode(node) && node.fn === "unaryMinus" && isConstantNode(node.args[0]) || state.tokenType === 2 /* NUMBER */ && !isConstantNode(last) && (!isOperatorNode(last) || last.op === "!") || state.token === "(") {
-          last = parseRule2(state);
+        if (state.tokenType === 3 /* SYMBOL */ || state.token === "in" && isConstantNode(node) || state.token === "in" && isOperatorNode(node) && node.fn === "unaryMinus" && isConstantNode(node.args[0]) || state.tokenType === 2 /* NUMBER */ && !isConstantNode(last2) && (!isOperatorNode(last2) || last2.op === "!") || state.token === "(") {
+          last2 = parseRule2(state);
           node = new OperatorNode(
             "*",
             "multiply",
-            [node, last],
+            [node, last2],
             true
             /* implicit */
           );
@@ -1702,10 +1345,10 @@ var createParse = /* @__PURE__ */ factory(
     }
     function parseRule2(state) {
       let node = parseUnaryPercentage(state);
-      let last = node;
+      let last2 = node;
       const tokenStates = [];
       while (true) {
-        if (state.token === "/" && rule2Node(last)) {
+        if (state.token === "/" && rule2Node(last2)) {
           tokenStates.push(Object.assign({}, state));
           getTokenSkipNewline(state);
           if (state.tokenType === 2 /* NUMBER */) {
@@ -1714,8 +1357,8 @@ var createParse = /* @__PURE__ */ factory(
             if (state.tokenType === 3 /* SYMBOL */ || state.token === "(" || state.token === "in") {
               Object.assign(state, tokenStates.pop());
               tokenStates.pop();
-              last = parseUnaryPercentage(state);
-              node = new OperatorNode("/", "divide", [node, last]);
+              last2 = parseUnaryPercentage(state);
+              node = new OperatorNode("/", "divide", [node, last2]);
             } else {
               tokenStates.pop();
               Object.assign(state, tokenStates.pop());
@@ -2114,225 +1757,16 @@ var createParse = /* @__PURE__ */ factory(
   }
 );
 
-// src/utils/customs.ts
-function getSafeProperty(object, prop) {
-  if (isSafeProperty(object, prop)) {
-    return object[prop];
-  }
-  if (typeof object[prop] === "function" && isSafeMethod(object, prop)) {
-    throw new Error('Cannot access method "' + String(prop) + '" as a property');
-  }
-  throw new Error('No access to property "' + String(prop) + '"');
-}
-function setSafeProperty(object, prop, value) {
-  if (isSafeProperty(object, prop)) {
-    object[prop] = value;
-    return value;
-  }
-  throw new Error('No access to property "' + String(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 getSafeMethod(object, method) {
-  if (!isSafeMethod(object, method)) {
-    throw new Error('No access to method "' + String(method) + '"');
-  }
-  return object[method];
-}
-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/utils/map.ts
-var ObjectWrappingMap = class {
-  wrappedObject;
-  [Symbol.toStringTag] = "ObjectWrappingMap";
-  constructor(object) {
-    this.wrappedObject = object;
-    this[Symbol.iterator] = 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;
-    this[Symbol.iterator] = 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;
-}
+import {
+  ObjectWrappingMap,
+  PartitionedMap,
+  createEmptyMap,
+  createMap,
+  toObject,
+  assignMap,
+  isObjectWrappingMap
+} from "@danielsimonjr/mathts-core/internal";
 
 // src/Parser.ts
 var name2 = "Parser";
@@ -2445,6 +1879,15 @@ var createParser = /* @__PURE__ */ factory(
   }
 );
 
+// src/utils/string.ts
+import {
+  endsWith,
+  formatGeneric,
+  stringify,
+  escape,
+  compareText
+} from "@danielsimonjr/mathts-core/internal";
+
 // src/Help.ts
 var name4 = "Help";
 var dependencies4 = ["evaluate"];
@@ -2496,7 +1939,7 @@ var createHelpClass = /* @__PURE__ */ factory(
             res = e;
           }
           if (res !== void 0 && !isHelp(res)) {
-            desc += "        " + format3(res, { precision: 14 }) + "\n";
+            desc += "        " + formatGeneric(res, { precision: 14 }) + "\n";
           }
         }
         desc += "\n";
@@ -7267,6 +6710,75 @@ var embeddedDocs = {
   gammainc: gammaincDocs
 };
 
+// src/utils/customs.ts
+function getSafeProperty(object, prop) {
+  if (isSafeProperty(object, prop)) {
+    return object[prop];
+  }
+  if (typeof object[prop] === "function" && isSafeMethod(object, prop)) {
+    throw new Error('Cannot access method "' + String(prop) + '" as a property');
+  }
+  throw new Error('No access to property "' + String(prop) + '"');
+}
+function setSafeProperty(object, prop, value) {
+  if (isSafeProperty(object, prop)) {
+    object[prop] = value;
+    return value;
+  }
+  throw new Error('No access to property "' + String(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 getSafeMethod(object, method) {
+  if (!isSafeMethod(object, method)) {
+    throw new Error('No access to method "' + String(method) + '"');
+  }
+  return object[method];
+}
+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/compiler/compile.ts
 function compile(node, mathScope) {
   const evalFn = compileNode(node, mathScope, {});
@@ -8336,6 +7848,9 @@ ${nodes.concat(edges).join("\n")}
   { isClass: true, isNode: true }
 );
 
+// src/error/IndexError.ts
+import { IndexError, createIndexError } from "@danielsimonjr/mathts-core/internal";
+
 // src/transform/utils/errorTransform.ts
 function errorTransform(err) {
   const e = err;
@@ -8570,6 +8085,41 @@ var createAccessorNode = /* @__PURE__ */ factory(
   { isClass: true, isNode: true }
 );
 
+// src/utils/array.ts
+import {
+  arraySize,
+  validate,
+  validateIndexSourceSize,
+  validateIndex,
+  isEmptyIndex,
+  resize,
+  reshape,
+  processSizesWildcard,
+  squeeze,
+  unsqueeze,
+  flatten,
+  map,
+  forEach,
+  filter,
+  filterRegExp,
+  join,
+  identify,
+  generalize,
+  getArrayDataType,
+  last,
+  initial,
+  concat,
+  broadcastSizes,
+  checkBroadcastingRules,
+  broadcastTo,
+  broadcastArrays,
+  stretch,
+  getArrayElement,
+  deepMapArray,
+  deepForEachArray,
+  cloneArray
+} from "@danielsimonjr/mathts-core/internal";
+
 // src/node/ArrayNode.ts
 var name7 = "ArrayNode";
 var dependencies7 = ["Node"];
@@ -9868,7 +9418,7 @@ var createConstantNode = /* @__PURE__ */ factory(
        * @return {string} str
        */
       _toString(options) {
-        return format3(this.value, options);
+        return formatGeneric(this.value, options);
       }
       /**
        * Get HTML representation
@@ -10193,7 +9743,7 @@ var createFunctionNode = /* @__PURE__ */ factory(
     Node,
     SymbolNode
   }) => {
-    const strin = (entity) => format3(entity, { truncate: 78 });
+    const strin = (entity) => formatGeneric(entity, { truncate: 78 });
     function expandTemplate(template, node, options) {
       let latex = "";
       const regex = /\$(?:\{([a-z_][a-z_0-9]*)(?:\[([0-9]+)\])?\}|\$)/gi;
@@ -12449,9 +11999,9 @@ var createColumnTransform = /* @__PURE__ */ factory(
     return typed("column", {
       "...any": function(args) {
         const lastIndex = args.length - 1;
-        const last = args[lastIndex];
-        if (isNumber(last)) {
-          args[lastIndex] = last - 1;
+        const last2 = args[lastIndex];
+        if (isNumber(last2)) {
+          args[lastIndex] = last2 - 1;
         }
         try {
           return column(...args);
@@ -12470,18 +12020,18 @@ var dependencies25 = ["typed", "concat"];
 var createConcatTransform = /* @__PURE__ */ factory(
   name25,
   dependencies25,
-  ({ typed, concat }) => {
+  ({ typed, concat: concat2 }) => {
     return typed("concat", {
       "...any": function(args) {
         const lastIndex = args.length - 1;
-        const last = args[lastIndex];
-        if (isNumber(last)) {
-          args[lastIndex] = last - 1;
-        } else if (isBigNumber(last)) {
-          args[lastIndex] = last.minus(1);
+        const last2 = args[lastIndex];
+        if (isNumber(last2)) {
+          args[lastIndex] = last2 - 1;
+        } else if (isBigNumber(last2)) {
+          args[lastIndex] = last2.minus(1);
         }
         try {
-          return concat(...args);
+          return concat2(...args);
         } catch (err) {
           throw errorTransform(err);
         }
@@ -12656,15 +12206,15 @@ var dependencies29 = ["typed", "filter"];
 var createFilterTransform = /* @__PURE__ */ factory(
   name29,
   dependencies29,
-  ({ typed, filter }) => {
+  ({ typed, filter: filter2 }) => {
     function filterTransform(args, math, scope) {
       const transformCallback = createTransformCallback({ typed });
       if (args.length === 0) {
-        return filter();
+        return filter2();
       }
       let x = args[0];
       if (args.length === 1) {
-        return filter(x);
+        return filter2(x);
       }
       const N = args.length - 1;
       let callback = args[N];
@@ -12682,7 +12232,7 @@ var createFilterTransform = /* @__PURE__ */ factory(
           );
         }
       }
-      return filter(x, transformCallback(callback, N));
+      return filter2(x, transformCallback(callback, N));
     }
     filterTransform.rawArgs = true;
     function _compileAndEvaluate(arg, scope) {
@@ -12742,7 +12292,7 @@ var dependencies31 = ["Index", "getMatrixDataType"];
 var createIndexTransform = /* @__PURE__ */ factory(
   name31,
   dependencies31,
-  ({ Index: Index2, getMatrixDataType }) => {
+  ({ Index, getMatrixDataType }) => {
     return function indexTransform(...args) {
       const transformedArgs = [];
       for (let i = 0, ii = args.length; i < ii; i++) {
@@ -12772,7 +12322,7 @@ var createIndexTransform = /* @__PURE__ */ factory(
         }
         transformedArgs[i] = arg;
       }
-      return new Index2(...transformedArgs);
+      return new Index(...transformedArgs);
     };
   },
   { isTransformFunction: true }
@@ -13019,8 +12569,8 @@ var createRangeTransform = /* @__PURE__ */ factory(
     return typed("range", {
       "...any": function(args) {
         const lastIndex = args.length - 1;
-        const last = args[lastIndex];
-        if (typeof last !== "boolean") {
+        const last2 = args[lastIndex];
+        if (typeof last2 !== "boolean") {
           args.push(true);
         }
         return range(...args);
@@ -13040,9 +12590,9 @@ var createRowTransform = /* @__PURE__ */ factory(
     return typed("row", {
       "...any": function(args) {
         const lastIndex = args.length - 1;
-        const last = args[lastIndex];
-        if (isNumber(last)) {
-          args[lastIndex] = last - 1;
+        const last2 = args[lastIndex];
+        if (isNumber(last2)) {
+          args[lastIndex] = last2 - 1;
         }
         try {
           return row(...args);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danielsimonjr/mathts-expression",
-  "version": "0.6.3",
+  "version": "0.6.5",
   "description": "Expression parser and evaluator for MathTS",
   "author": "Daniel Simon Jr.",
   "license": "MIT",
@@ -31,7 +31,7 @@
     "build:prod": "tsup src/index.ts --format esm --dts --clean --minify --treeshake"
   },
   "dependencies": {
-    "@danielsimonjr/mathts-core": "^0.9.0",
+    "@danielsimonjr/mathts-core": "^0.11.0",
     "typed-function": "^4.0.0"
   },
   "devDependencies": {