@danielsimonjr/mathts-expression 0.4.1 → 0.4.3

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+import { NumberTypeConfig } from '@danielsimonjr/mathts-core/internal';
+
 type TypedFunction$1 = ((...args: unknown[]) => unknown) & {
     signatures: Record<string, (...args: unknown[]) => unknown>;
 };
@@ -96,14 +98,6 @@ interface FactoryMeta {
     [key: string]: unknown;
 }
 
-/**
- * Configuration for number type handling
- */
-interface NumberTypeConfig {
-    number: 'number' | 'BigNumber' | 'bigint' | 'Fraction';
-    numberFallback: 'number' | 'BigNumber';
-}
-
 type Scope$1 = Map<string, unknown>;
 interface CompiledExpression$1 {
     evaluate: (scope?: Record<string, unknown>) => unknown;

package/dist/index.js

@@ -100,6 +100,25 @@ var require_dist = __commonJS({
 // src/keywords.ts
 var keywords = /* @__PURE__ */ new Set(["end"]);
 
+// src/utils/object.ts
+import {
+  canDefineProperty,
+  clone,
+  deepExtend,
+  deepFlatten,
+  deepStrictEqual,
+  extend,
+  get,
+  hasOwnProperty,
+  isLegacyFactory,
+  lazy,
+  mapObject,
+  pick,
+  pickShallow,
+  set,
+  traverse
+} from "@danielsimonjr/mathts-core/internal";
+
 // src/utils/is.ts
 function isNumber(x) {
   return typeof x === "number";
@@ -228,90 +247,6 @@ function typeOf(x) {
   return t;
 }
 
-// src/utils/object.ts
-function clone(x) {
-  const type = typeof x;
-  if (type === "number" || type === "bigint" || type === "string" || type === "boolean" || x === null || x === void 0) {
-    return x;
-  }
-  const cloneable = x;
-  if (typeof cloneable.clone === "function") {
-    return cloneable.clone();
-  }
-  if (Array.isArray(x)) {
-    return x.map((value) => clone(value));
-  }
-  if (x instanceof Date) return new Date(x.valueOf());
-  if (isBigNumber(x)) return x;
-  if (isObject(x)) {
-    return mapObject(x, clone);
-  }
-  if (type === "function") {
-    return x;
-  }
-  throw new TypeError(`Cannot clone: unknown type of value (value: ${x})`);
-}
-function mapObject(object, callback) {
-  const clone2 = {};
-  for (const key in object) {
-    if (hasOwnProperty(object, key)) {
-      clone2[key] = callback(object[key]);
-    }
-  }
-  return clone2;
-}
-function deepStrictEqual(a, b) {
-  if (Array.isArray(a)) {
-    if (!Array.isArray(b)) {
-      return false;
-    }
-    if (a.length !== b.length) {
-      return false;
-    }
-    for (let i = 0, len = a.length; i < len; i++) {
-      if (!deepStrictEqual(a[i], b[i])) {
-        return false;
-      }
-    }
-    return true;
-  } else if (typeof a === "function") {
-    return a === b;
-  } else if (a instanceof Object) {
-    if (Array.isArray(b) || !(b instanceof Object)) {
-      return false;
-    }
-    const objA = a;
-    const objB = b;
-    for (const prop in objA) {
-      if (!(prop in objB) || !deepStrictEqual(objA[prop], objB[prop])) {
-        return false;
-      }
-    }
-    for (const prop in objB) {
-      if (!(prop in objA)) {
-        return false;
-      }
-    }
-    return true;
-  } else {
-    return a === b;
-  }
-}
-function hasOwnProperty(object, property) {
-  return !!object && Object.hasOwnProperty.call(object, property);
-}
-function pickShallow(object, properties2) {
-  const copy = {};
-  for (let i = 0; i < properties2.length; i++) {
-    const key = properties2[i];
-    const value = object[key];
-    if (value !== void 0) {
-      copy[key] = value;
-    }
-  }
-  return copy;
-}
-
 // src/operators.ts
 var properties = [
   {
@@ -756,291 +691,33 @@ var IndexError = class _IndexError extends RangeError {
 };
 
 // src/utils/number.ts
-function isInteger(value) {
-  if (typeof value === "boolean") {
-    return true;
-  }
-  return isFinite(value) ? value === Math.round(value) : false;
-}
-function safeNumberType(numberStr, config) {
-  if (config.number === "bigint") {
-    try {
-      BigInt(numberStr);
-    } catch {
-      return config.numberFallback;
-    }
-  }
-  return config.number;
-}
-function formatNumberToBase(n, base, size) {
-  const prefixes = { 2: "0b", 8: "0o", 16: "0x" };
-  const prefix = prefixes[base];
-  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 > 2 ** (size - 1) - 1 || n < -(2 ** (size - 1))) {
-      throw new Error(`Value must be in range [-2^${size - 1}, 2^${size - 1}-1]`);
-    }
-    if (!isInteger(n)) {
-      throw new Error("Value must be an integer");
-    }
-    if (n < 0) {
-      n = n + 2 ** size;
-    }
-    suffix = `i${size}`;
-  }
-  let sign = "";
-  if (n < 0) {
-    n = -n;
-    sign = "-";
-  }
-  return `${sign}${prefix}${n.toString(base)}${suffix}`;
-}
-function format(value, options) {
-  if (typeof options === "function") {
-    return options(value);
-  }
-  if (value === Infinity) {
-    return "Infinity";
-  } else if (value === -Infinity) {
-    return "-Infinity";
-  } else if (isNaN(value)) {
-    return "NaN";
-  }
-  const { notation, precision, wordSize } = normalizeFormatOptions(options);
-  switch (notation) {
-    case "fixed":
-      return toFixed(value, precision);
-    case "exponential":
-      return toExponential(value, precision);
-    case "engineering":
-      return toEngineering(value, precision);
-    case "bin":
-      return formatNumberToBase(value, 2, wordSize);
-    case "oct":
-      return formatNumberToBase(value, 8, wordSize);
-    case "hex":
-      return formatNumberToBase(value, 16, wordSize);
-    case "auto":
-      return toPrecision(value, precision, options).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 normalizeFormatOptions(options) {
-  let notation = "auto";
-  let precision;
-  let wordSize;
-  if (options !== void 0) {
-    if (isNumber(options)) {
-      precision = options;
-    } else if (isBigNumber(options)) {
-      precision = options.toNumber();
-    } else if (isObject(options)) {
-      if (options.precision !== void 0) {
-        precision = _toNumberOrThrow(options.precision, () => {
-          throw new Error('Option "precision" must be a number or BigNumber');
-        });
-      }
-      if (options.wordSize !== void 0) {
-        wordSize = _toNumberOrThrow(options.wordSize, () => {
-          throw new Error('Option "wordSize" must be a number or BigNumber');
-        });
-      }
-      if (options.notation) {
-        notation = options.notation;
-      }
-    } else {
-      throw new Error("Unsupported type of options, number, BigNumber, or object expected");
-    }
-  }
-  return { notation, precision, wordSize };
-}
-function splitNumber(value) {
-  const match = String(value).toLowerCase().match(/^(-?)(\d+\.?\d*)(e([+-]?\d+))?$/);
-  if (!match) {
-    throw new SyntaxError("Invalid number " + value);
-  }
-  const sign = match[1];
-  const digits = match[2];
-  let exponent = parseFloat(match[4] || "0");
-  const dot = digits.indexOf(".");
-  exponent += dot !== -1 ? dot - 1 : digits.length - 1;
-  const coefficients = digits.replace(".", "").replace(/^0*/, function(zeros2) {
-    exponent -= zeros2.length;
-    return "";
-  }).replace(/0*$/, "").split("").map(function(d) {
-    return parseInt(d);
-  });
-  if (coefficients.length === 0) {
-    coefficients.push(0);
-    exponent++;
-  }
-  return { sign, coefficients, exponent };
-}
-function toEngineering(value, precision) {
-  if (isNaN(value) || !isFinite(value)) {
-    return String(value);
-  }
-  const split = splitNumber(value);
-  const rounded = roundDigits(split, precision);
-  const e = rounded.exponent;
-  const c = rounded.coefficients;
-  const newExp = e % 3 === 0 ? e : e < 0 ? e - 3 - e % 3 : e - e % 3;
-  if (isNumber(precision)) {
-    while (precision > c.length || e - newExp + 1 > c.length) {
-      c.push(0);
-    }
-  } else {
-    const missingZeros = Math.abs(e - newExp) - (c.length - 1);
-    for (let i = 0; i < missingZeros; i++) {
-      c.push(0);
-    }
-  }
-  let expDiff = Math.abs(e - newExp);
-  let decimalIdx = 1;
-  while (expDiff > 0) {
-    decimalIdx++;
-    expDiff--;
-  }
-  const decimals = c.slice(decimalIdx).join("");
-  const decimalVal = isNumber(precision) && decimals.length || decimals.match(/[1-9]/) ? "." + decimals : "";
-  const str = c.slice(0, decimalIdx).join("") + decimalVal + "e" + (e >= 0 ? "+" : "") + newExp.toString();
-  return rounded.sign + str;
-}
-function toFixed(value, precision) {
-  if (isNaN(value) || !isFinite(value)) {
-    return String(value);
-  }
-  const splitValue = splitNumber(value);
-  const rounded = typeof precision === "number" ? roundDigits(splitValue, splitValue.exponent + 1 + precision) : splitValue;
-  let c = rounded.coefficients;
-  let p = rounded.exponent + 1;
-  const pp = p + (precision || 0);
-  if (c.length < pp) {
-    c = c.concat(zeros(pp - c.length));
-  }
-  if (p < 0) {
-    c = zeros(-p + 1).concat(c);
-    p = 1;
-  }
-  if (p < c.length) {
-    c.splice(p, 0, p === 0 ? "0." : ".");
-  }
-  return rounded.sign + c.join("");
-}
-function toExponential(value, precision) {
-  if (isNaN(value) || !isFinite(value)) {
-    return String(value);
-  }
-  const split = splitNumber(value);
-  const rounded = precision ? roundDigits(split, precision) : split;
-  let c = rounded.coefficients;
-  const e = rounded.exponent;
-  if (precision && c.length < precision) {
-    c = c.concat(zeros(precision - c.length));
-  }
-  const first = c.shift();
-  return rounded.sign + first + (c.length > 0 ? "." + c.join("") : "") + "e" + (e >= 0 ? "+" : "") + e;
-}
-function toPrecision(value, precision, options) {
-  if (isNaN(value) || !isFinite(value)) {
-    return String(value);
-  }
-  const lowerExp = _toNumberOrDefault(options?.lowerExp, -3);
-  const upperExp = _toNumberOrDefault(options?.upperExp, 5);
-  const split = splitNumber(value);
-  const rounded = precision ? roundDigits(split, precision) : split;
-  if (rounded.exponent < lowerExp || rounded.exponent >= upperExp) {
-    return toExponential(value, precision);
-  } else {
-    let c = rounded.coefficients;
-    const e = rounded.exponent;
-    if (precision && c.length < precision) {
-      c = c.concat(zeros(precision - c.length));
-    }
-    c = c.concat(
-      zeros(e - c.length + 1 + (precision && c.length < precision ? precision - c.length : 0))
-    );
-    c = zeros(-e).concat(c);
-    const dot = e > 0 ? e : 0;
-    if (dot < c.length - 1) {
-      c.splice(dot + 1, 0, ".");
-    }
-    return rounded.sign + c.join("");
-  }
-}
-function roundDigits(split, precision) {
-  const rounded = {
-    sign: split.sign,
-    coefficients: split.coefficients.slice(),
-    exponent: split.exponent
-  };
-  const c = rounded.coefficients;
-  if (precision !== void 0) {
-    while (precision <= 0) {
-      c.unshift(0);
-      rounded.exponent++;
-      precision++;
-    }
-    if (c.length > precision) {
-      const removed = c.splice(precision, c.length - precision);
-      if (removed[0] >= 5) {
-        let i = precision - 1;
-        c[i]++;
-        while (c[i] === 10) {
-          c.pop();
-          if (i === 0) {
-            c.unshift(0);
-            rounded.exponent++;
-            i++;
-          }
-          i--;
-          c[i]++;
-        }
-      }
-    }
-  }
-  return rounded;
-}
-function zeros(length) {
-  const arr = [];
-  for (let i = 0; i < length; i++) {
-    arr.push(0);
-  }
-  return arr;
-}
-function _toNumberOrThrow(value, onError) {
-  if (isNumber(value)) {
-    return value;
-  } else if (isBigNumber(value)) {
-    return value.toNumber();
-  } else {
-    onError();
-    return 0;
-  }
-}
-function _toNumberOrDefault(value, defaultValue) {
-  if (isNumber(value)) {
-    return value;
-  } else if (isBigNumber(value)) {
-    return value.toNumber();
-  } else {
-    return defaultValue;
-  }
-}
+import {
+  acosh,
+  asinh,
+  atanh,
+  cbrt,
+  copysign,
+  cosh,
+  digits,
+  expm1,
+  format,
+  isInteger,
+  log10,
+  log1p,
+  log2,
+  nearlyEqual,
+  normalizeFormatOptions,
+  roundDigits,
+  safeNumberType,
+  sign,
+  sinh,
+  splitNumber,
+  tanh,
+  toEngineering,
+  toExponential,
+  toFixed,
+  toPrecision
+} from "@danielsimonjr/mathts-core/internal";
 
 // src/utils/bignumber/formatter.ts
 function formatBigNumberToBase(n, base, size) {
@@ -1099,8 +776,8 @@ function format2(value, options) {
       return formatBigNumberToBase(value, 16, wordSize);
     case "auto": {
       const optionsObject = typeof options === "object" ? options : void 0;
-      const lowerExp = _toNumberOrDefault2(optionsObject?.lowerExp, -3);
-      const upperExp = _toNumberOrDefault2(optionsObject?.upperExp, 5);
+      const lowerExp = _toNumberOrDefault(optionsObject?.lowerExp, -3);
+      const upperExp = _toNumberOrDefault(optionsObject?.upperExp, 5);
       if (value.isZero()) return "0";
       let str;
       const rounded = value.toSignificantDigits(precision);
@@ -1112,8 +789,8 @@ function format2(value, options) {
       }
       return str.replace(
         /((\.\d*?)(0+))($|e)/,
-        function(_match, _g1, digits, _g3, e) {
-          return digits !== "." ? digits + e : e;
+        function(_match, _g1, digits2, _g3, e) {
+          return digits2 !== "." ? digits2 + e : e;
         }
       );
     }
@@ -1144,7 +821,7 @@ function toExponential2(value, precision) {
 function toFixed2(value, precision) {
   return value.toFixed(precision);
 }
-function _toNumberOrDefault2(value, defaultValue) {
+function _toNumberOrDefault(value, defaultValue) {
   if (isNumber(value)) {
     return value;
   } else if (isBigNumber(value)) {
@@ -7146,9 +6823,9 @@ function numberToMathML(value) {
   const s = String(value);
   const sci = /^(-?)(\d+(?:\.\d+)?)[eE]([+-]?\d+)$/.exec(s);
   if (sci) {
-    const sign = sci[1] ? "<mo>-</mo>" : "";
+    const sign2 = sci[1] ? "<mo>-</mo>" : "";
     const exp = String(parseInt(sci[3], 10));
-    return `<mrow>${sign}<mn>${sci[2]}</mn><mo>&#xD7;</mo><msup><mn>10</mn><mn>${exp}</mn></msup></mrow>`;
+    return `<mrow>${sign2}<mn>${sci[2]}</mn><mo>&#xD7;</mo><msup><mn>10</mn><mn>${exp}</mn></msup></mrow>`;
   }
   if (value < 0) return `<mrow><mo>-</mo><mn>${escapeMathML(String(-value))}</mn></mrow>`;
   return `<mn>${escapeMathML(s)}</mn>`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danielsimonjr/mathts-expression",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "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.2.0",
+    "@danielsimonjr/mathts-core": "^0.4.0",
     "typed-function": "^4.0.0"
   },
   "devDependencies": {