@pie-lib/math-evaluator 2.17.1-next.0 → 2.18.1

package/esm/index.js

@@ -0,0 +1,175 @@
+import * as mathjs from 'mathjs';
+import me from '@pie-framework/math-expressions';
+
+function _extends() {
+  _extends = Object.assign || function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+
+    return target;
+  };
+
+  return _extends.apply(this, arguments);
+}
+
+const decimalCommaRegex = /,/g;
+const decimalRegex = /\.|,/g;
+const decimalWithThousandSeparatorNumberRegex = /^(?!0+\.00)(?=.{1,9}(\.|$))(?!0(?!\.))\d{1,3}(,\d{3})*(\.\d+)?$/;
+
+const rationalizeAllPossibleSubNodes = expression => rationalize(mathjs.parse(expression));
+
+const rationalize = tree => {
+  const transformedTree = tree.transform(node => {
+    try {
+      const rationalizedNode = mathjs.rationalize(node);
+      return rationalizedNode;
+    } catch (_unused) {
+      return node;
+    }
+  });
+  return transformedTree;
+};
+
+function prepareExpression(string, isLatex) {
+  let returnValue = string ? string.trim() : '';
+  returnValue = returnValue.replace(decimalCommaRegex, '.');
+  returnValue = isLatex ? latexToText(`${returnValue}`) : textToMathText(`${returnValue}`, {
+    unknownCommands: 'passthrough'
+  }).toString();
+  returnValue = returnValue.replace('=', '==');
+  return rationalizeAllPossibleSubNodes(returnValue);
+}
+
+const latexToAstOpts = {
+  missingFactor: (token, e) => {
+    console.warn('missing factor for: ', token.token_type);
+
+    if (token.token_type === 'NUMBER') {
+      throw e;
+    }
+
+    return 0;
+  },
+  unknownCommandBehavior: 'passthrough'
+};
+const astToTextOpts = {
+  unicode_operators: {
+    ne: function (operands) {
+      return operands.join(' != ');
+    },
+    '%': function (operands) {
+      return `percent(${operands[0]})`;
+    }
+  }
+};
+const latexToText = (latex, extraOtps = {}) => {
+  const la = new me.converters.latexToAstObj(_extends({}, latexToAstOpts, extraOtps));
+  const at = new me.converters.astToTextObj(_extends({}, astToTextOpts, extraOtps));
+  const ast = la.convert(latex);
+  return at.convert(ast);
+};
+const textToMathText = (latex, extraOtps = {}) => {
+  const la = new me.converters.textToAstObj(_extends({}, latexToAstOpts, extraOtps));
+  const at = new me.converters.astToTextObj(_extends({}, astToTextOpts, extraOtps));
+  const ast = la.convert(latex);
+  return at.convert(ast);
+};
+
+function shouldRationalizeEntireTree(tree) {
+  let shouldDoIt = true; // we need to iterate the entire tree to check for some conditions that might make rationalization impossible
+
+  try {
+    tree.traverse(node => {
+      // if we have a variable as an exponent for power operation, we should not rationalize
+      // try to see if there are power operations with variable exponents
+      if (node.type === 'OperatorNode' && node.fn === 'pow') {
+        const exponent = node.args[1]; // try to see if it can be compiled and evaluated - if it's a non-numerical value, it'll throw an error
+
+        exponent.compile().eval();
+      } // we cannot have variables for unresolved function calls either
+
+
+      if (node.type === 'FunctionNode') {
+        //try to see if the argument that the function is called with can be resolved as non-variable
+        const functionParameter = node.args[0]; // if it holds variables, this will throw an error
+
+        functionParameter.compile().eval();
+      }
+    });
+    mathjs.rationalize(tree);
+  } catch (_unused2) {
+    shouldDoIt = false;
+  }
+
+  return shouldDoIt;
+}
+
+function containsDecimal(expression = '') {
+  return expression.match(decimalRegex);
+}
+
+const SIMPLIFY_RULES = [{
+  l: 'n1^(1/n2)',
+  r: 'nthRoot(n1, n2)'
+}, {
+  l: 'sqrt(n1)',
+  r: 'nthRoot(n1, 2)'
+}];
+
+const simplify = v => mathjs.simplify(v, SIMPLIFY_RULES.concat(mathjs.simplify.rules)); //.concat(SIMPLIFY_RULES));
+
+
+const areValuesEqual = (valueOne, valueTwo, options = {}) => {
+  const {
+    // if explicitly set to false, having a decimal value in either side will result in a false equality
+    // regardless of mathematical correctness
+    allowDecimals,
+    isLatex,
+    // if the passed in values are latex, they need to be escaped
+    inverse // returns inverse for the comparison result
+
+  } = options;
+  let valueOneToUse = valueOne;
+  let valueTwoToUse = valueTwo;
+
+  if (allowDecimals === false) {
+    if (containsDecimal(valueOne) || containsDecimal(valueTwo)) {
+      return false;
+    }
+  } else if (allowDecimals === true) {
+    if (containsDecimal(valueOne) && decimalWithThousandSeparatorNumberRegex.test(valueOne)) {
+      valueOneToUse = valueOne.replace(decimalCommaRegex, '');
+    }
+
+    if (containsDecimal(valueTwo) && decimalWithThousandSeparatorNumberRegex.test(valueTwo)) {
+      valueTwoToUse = valueTwo.replace(decimalCommaRegex, '');
+    }
+  }
+
+  const preparedValueOne = prepareExpression(valueOneToUse, isLatex);
+  const preparedValueTwo = prepareExpression(valueTwoToUse, isLatex);
+  let one = shouldRationalizeEntireTree(preparedValueOne) ? mathjs.rationalize(preparedValueOne) : preparedValueOne;
+  let two = shouldRationalizeEntireTree(preparedValueTwo) ? mathjs.rationalize(preparedValueTwo) : preparedValueTwo;
+  one = simplify(one);
+  two = simplify(two);
+  const equals = one.equals(two);
+  return inverse ? !equals : equals;
+};
+
+const ave = (a, b) => {
+  const am = mathjs.parse(a);
+  const bm = mathjs.parse(b);
+  const arm = simplify(am);
+  const brm = simplify(bm);
+  return arm.equals(brm);
+};
+
+export { ave, areValuesEqual as default, latexToText, textToMathText };
+//# sourceMappingURL=index.js.map

package/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../src/index.js"],"sourcesContent":["/* eslint-disable no-console */\nimport * as mathjs from 'mathjs';\nimport me from '@pie-framework/math-expressions';\n\nconst decimalCommaRegex = /,/g;\nconst decimalRegex = /\\.|,/g;\nconst decimalWithThousandSeparatorNumberRegex = /^(?!0+\\.00)(?=.{1,9}(\\.|$))(?!0(?!\\.))\\d{1,3}(,\\d{3})*(\\.\\d+)?$/;\n\nconst rationalizeAllPossibleSubNodes = (expression) => rationalize(mathjs.parse(expression));\nconst rationalize = (tree) => {\n  const transformedTree = tree.transform((node) => {\n    try {\n      const rationalizedNode = mathjs.rationalize(node);\n      return rationalizedNode;\n    } catch {\n      return node;\n    }\n  });\n  return transformedTree;\n};\n\nfunction prepareExpression(string, isLatex) {\n  let returnValue = string ? string.trim() : '';\n\n  returnValue = returnValue.replace(decimalCommaRegex, '.');\n\n  returnValue = isLatex\n    ? latexToText(`${returnValue}`)\n    : textToMathText(`${returnValue}`, { unknownCommands: 'passthrough' }).toString();\n\n  returnValue = returnValue.replace('=', '==');\n  return rationalizeAllPossibleSubNodes(returnValue);\n}\n\nconst latexToAstOpts = {\n  missingFactor: (token, e) => {\n    console.warn('missing factor for: ', token.token_type);\n    if (token.token_type === 'NUMBER') {\n      throw e;\n    }\n    return 0;\n  },\n  unknownCommandBehavior: 'passthrough',\n};\n\nconst astToTextOpts = {\n  unicode_operators: {\n    ne: function(operands) {\n      return operands.join(' != ');\n    },\n    '%': function(operands) {\n      return `percent(${operands[0]})`;\n    },\n  },\n};\n\nexport const latexToText = (latex, extraOtps = {}) => {\n  const la = new me.converters.latexToAstObj({ ...latexToAstOpts, ...extraOtps });\n\n  const at = new me.converters.astToTextObj({ ...astToTextOpts, ...extraOtps });\n\n  const ast = la.convert(latex);\n\n  return at.convert(ast);\n};\n\nexport const textToMathText = (latex, extraOtps = {}) => {\n  const la = new me.converters.textToAstObj({ ...latexToAstOpts, ...extraOtps });\n\n  const at = new me.converters.astToTextObj({ ...astToTextOpts, ...extraOtps });\n\n  const ast = la.convert(latex);\n\n  return at.convert(ast);\n};\n\nfunction shouldRationalizeEntireTree(tree) {\n  let shouldDoIt = true;\n\n  // we need to iterate the entire tree to check for some conditions that might make rationalization impossible\n  try {\n    tree.traverse((node) => {\n      // if we have a variable as an exponent for power operation, we should not rationalize\n      // try to see if there are power operations with variable exponents\n      if (node.type === 'OperatorNode' && node.fn === 'pow') {\n        const exponent = node.args[1];\n\n        // try to see if it can be compiled and evaluated - if it's a non-numerical value, it'll throw an error\n        exponent.compile().eval();\n      }\n\n      // we cannot have variables for unresolved function calls either\n      if (node.type === 'FunctionNode') {\n        //try to see if the argument that the function is called with can be resolved as non-variable\n        const functionParameter = node.args[0];\n\n        // if it holds variables, this will throw an error\n        functionParameter.compile().eval();\n      }\n    });\n\n    mathjs.rationalize(tree);\n  } catch {\n    shouldDoIt = false;\n  }\n\n  return shouldDoIt;\n}\n\nfunction containsDecimal(expression = '') {\n  return expression.match(decimalRegex);\n}\nconst SIMPLIFY_RULES = [\n  { l: 'n1^(1/n2)', r: 'nthRoot(n1, n2)' },\n  { l: 'sqrt(n1)', r: 'nthRoot(n1, 2)' },\n];\n\nconst simplify = (v) => mathjs.simplify(v, SIMPLIFY_RULES.concat(mathjs.simplify.rules)); //.concat(SIMPLIFY_RULES));\n\nconst areValuesEqual = (valueOne, valueTwo, options = {}) => {\n  const {\n    // if explicitly set to false, having a decimal value in either side will result in a false equality\n    // regardless of mathematical correctness\n    allowDecimals,\n    isLatex, // if the passed in values are latex, they need to be escaped\n    inverse, // returns inverse for the comparison result\n  } = options;\n\n  let valueOneToUse = valueOne;\n  let valueTwoToUse = valueTwo;\n\n  if (allowDecimals === false) {\n    if (containsDecimal(valueOne) || containsDecimal(valueTwo)) {\n      return false;\n    }\n  } else if (allowDecimals === true) {\n    if (containsDecimal(valueOne) && decimalWithThousandSeparatorNumberRegex.test(valueOne)) {\n      valueOneToUse = valueOne.replace(decimalCommaRegex, '');\n    }\n\n    if (containsDecimal(valueTwo) && decimalWithThousandSeparatorNumberRegex.test(valueTwo)) {\n      valueTwoToUse = valueTwo.replace(decimalCommaRegex, '');\n    }\n  }\n\n  const preparedValueOne = prepareExpression(valueOneToUse, isLatex, allowDecimals);\n  const preparedValueTwo = prepareExpression(valueTwoToUse, isLatex, allowDecimals);\n\n  let one = shouldRationalizeEntireTree(preparedValueOne) ? mathjs.rationalize(preparedValueOne) : preparedValueOne;\n  let two = shouldRationalizeEntireTree(preparedValueTwo) ? mathjs.rationalize(preparedValueTwo) : preparedValueTwo;\n\n  one = simplify(one);\n  two = simplify(two);\n\n  const equals = one.equals(two);\n\n  return inverse ? !equals : equals;\n};\n\nexport const ave = (a, b) => {\n  const am = mathjs.parse(a);\n  const bm = mathjs.parse(b);\n\n  const arm = simplify(am);\n  const brm = simplify(bm);\n  return arm.equals(brm);\n};\n\nexport default areValuesEqual;\n"],"names":["decimalCommaRegex","decimalRegex","decimalWithThousandSeparatorNumberRegex","rationalizeAllPossibleSubNodes","expression","rationalize","mathjs","parse","tree","transformedTree","transform","node","rationalizedNode","prepareExpression","string","isLatex","returnValue","trim","replace","latexToText","textToMathText","unknownCommands","toString","latexToAstOpts","missingFactor","token","e","console","warn","token_type","unknownCommandBehavior","astToTextOpts","unicode_operators","ne","operands","join","latex","extraOtps","la","me","converters","latexToAstObj","at","astToTextObj","ast","convert","textToAstObj","shouldRationalizeEntireTree","shouldDoIt","traverse","type","fn","exponent","args","compile","eval","functionParameter","containsDecimal","match","SIMPLIFY_RULES","l","r","simplify","v","concat","rules","areValuesEqual","valueOne","valueTwo","options","allowDecimals","inverse","valueOneToUse","valueTwoToUse","test","preparedValueOne","preparedValueTwo","one","two","equals","ave","a","b","am","bm","arm","brm"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAIA,MAAMA,iBAAiB,GAAG,IAA1B;AACA,MAAMC,YAAY,GAAG,OAArB;AACA,MAAMC,uCAAuC,GAAG,iEAAhD;;AAEA,MAAMC,8BAA8B,GAAIC,UAAD,IAAgBC,WAAW,CAACC,MAAM,CAACC,KAAP,CAAaH,UAAb,CAAD,CAAlE;;AACA,MAAMC,WAAW,GAAIG,IAAD,IAAU;AAC5B,EAAA,MAAMC,eAAe,GAAGD,IAAI,CAACE,SAAL,CAAgBC,IAAD,IAAU;AAC/C,IAAA,IAAI;AACF,MAAA,MAAMC,gBAAgB,GAAGN,MAAM,CAACD,WAAP,CAAmBM,IAAnB,CAAzB;AACA,MAAA,OAAOC,gBAAP;AACD,IAAA,CAHD,CAGE,OAAA,OAAA,EAAM;AACN,MAAA,OAAOD,IAAP;AACD,IAAA;AACF,EAAA,CAPuB,CAAxB;AAQA,EAAA,OAAOF,eAAP;AACD,CAVD;;AAYA,SAASI,iBAAT,CAA2BC,MAA3B,EAAmCC,OAAnC,EAA4C;AAC1C,EAAA,IAAIC,WAAW,GAAGF,MAAM,GAAGA,MAAM,CAACG,IAAP,EAAH,GAAmB,EAA3C;AAEAD,EAAAA,WAAW,GAAGA,WAAW,CAACE,OAAZ,CAAoBlB,iBAApB,EAAuC,GAAvC,CAAd;AAEAgB,EAAAA,WAAW,GAAGD,OAAO,GACjBI,WAAW,CAAE,CAAA,EAAEH,WAAY,CAAA,CAAhB,CADM,GAEjBI,cAAc,CAAE,CAAA,EAAEJ,WAAY,EAAhB,EAAmB;AAAEK,IAAAA,eAAe,EAAE;AAAnB,GAAnB,CAAd,CAAqEC,QAArE,EAFJ;AAIAN,EAAAA,WAAW,GAAGA,WAAW,CAACE,OAAZ,CAAoB,GAApB,EAAyB,IAAzB,CAAd;AACA,EAAA,OAAOf,8BAA8B,CAACa,WAAD,CAArC;AACD;;AAED,MAAMO,cAAc,GAAG;AACrBC,EAAAA,aAAa,EAAE,CAACC,KAAD,EAAQC,CAAR,KAAc;AAC3BC,IAAAA,OAAO,CAACC,IAAR,CAAa,sBAAb,EAAqCH,KAAK,CAACI,UAA3C,CAAA;;AACA,IAAA,IAAIJ,KAAK,CAACI,UAAN,KAAqB,QAAzB,EAAmC;AACjC,MAAA,MAAMH,CAAN;AACD,IAAA;;AACD,IAAA,OAAO,CAAP;AACD,EAAA,CAPoB;AAQrBI,EAAAA,sBAAsB,EAAE;AARH,CAAvB;AAWA,MAAMC,aAAa,GAAG;AACpBC,EAAAA,iBAAiB,EAAE;AACjBC,IAAAA,EAAE,EAAE,UAASC,QAAT,EAAmB;AACrB,MAAA,OAAOA,QAAQ,CAACC,IAAT,CAAc,MAAd,CAAP;AACD,IAAA,CAHgB;AAIjB,IAAA,GAAA,EAAK,UAASD,QAAT,EAAmB;AACtB,MAAA,OAAQ,CAAA,QAAA,EAAUA,QAAQ,CAAC,CAAD,CAAI,CAAA,CAAA,CAA9B;AACD,IAAA;AANgB;AADC,CAAtB;AAWO,MAAMf,WAAW,GAAG,CAACiB,KAAD,EAAQC,SAAS,GAAG,EAApB,KAA2B;AACpD,EAAA,MAAMC,EAAE,GAAG,IAAIC,EAAE,CAACC,UAAH,CAAcC,aAAlB,CAAA,QAAA,CAAA,EAAA,EAAqClB,cAArC,EAAwDc,SAAxD,CAAA,CAAX;AAEA,EAAA,MAAMK,EAAE,GAAG,IAAIH,EAAE,CAACC,UAAH,CAAcG,YAAlB,CAAA,QAAA,CAAA,EAAA,EAAoCZ,aAApC,EAAsDM,SAAtD,CAAA,CAAX;AAEA,EAAA,MAAMO,GAAG,GAAGN,EAAE,CAACO,OAAH,CAAWT,KAAX,CAAZ;AAEA,EAAA,OAAOM,EAAE,CAACG,OAAH,CAAWD,GAAX,CAAP;AACD;AAEM,MAAMxB,cAAc,GAAG,CAACgB,KAAD,EAAQC,SAAS,GAAG,EAApB,KAA2B;AACvD,EAAA,MAAMC,EAAE,GAAG,IAAIC,EAAE,CAACC,UAAH,CAAcM,YAAlB,CAAA,QAAA,CAAA,EAAA,EAAoCvB,cAApC,EAAuDc,SAAvD,CAAA,CAAX;AAEA,EAAA,MAAMK,EAAE,GAAG,IAAIH,EAAE,CAACC,UAAH,CAAcG,YAAlB,CAAA,QAAA,CAAA,EAAA,EAAoCZ,aAApC,EAAsDM,SAAtD,CAAA,CAAX;AAEA,EAAA,MAAMO,GAAG,GAAGN,EAAE,CAACO,OAAH,CAAWT,KAAX,CAAZ;AAEA,EAAA,OAAOM,EAAE,CAACG,OAAH,CAAWD,GAAX,CAAP;AACD;;AAED,SAASG,2BAAT,CAAqCvC,IAArC,EAA2C;AACzC,EAAA,IAAIwC,UAAU,GAAG,IAAjB,CADyC;;AAIzC,EAAA,IAAI;AACFxC,IAAAA,IAAI,CAACyC,QAAL,CAAetC,IAAD,IAAU;AACtB;AACA;AACA,MAAA,IAAIA,IAAI,CAACuC,IAAL,KAAc,cAAd,IAAgCvC,IAAI,CAACwC,EAAL,KAAY,KAAhD,EAAuD;AACrD,QAAA,MAAMC,QAAQ,GAAGzC,IAAI,CAAC0C,IAAL,CAAU,CAAV,CAAjB,CADqD;;AAIrDD,QAAAA,QAAQ,CAACE,OAAT,EAAA,CAAmBC,IAAnB,EAAA;AACD,MAAA,CARqB;;;AAWtB,MAAA,IAAI5C,IAAI,CAACuC,IAAL,KAAc,cAAlB,EAAkC;AAChC;AACA,QAAA,MAAMM,iBAAiB,GAAG7C,IAAI,CAAC0C,IAAL,CAAU,CAAV,CAA1B,CAFgC;;AAKhCG,QAAAA,iBAAiB,CAACF,OAAlB,EAAA,CAA4BC,IAA5B,EAAA;AACD,MAAA;AACF,IAAA,CAlBD,CAAA;AAoBAjD,IAAAA,MAAM,CAACD,WAAP,CAAmBG,IAAnB,CAAA;AACD,EAAA,CAtBD,CAsBE,OAAA,QAAA,EAAM;AACNwC,IAAAA,UAAU,GAAG,KAAb;AACD,EAAA;;AAED,EAAA,OAAOA,UAAP;AACD;;AAED,SAASS,eAAT,CAAyBrD,UAAU,GAAG,EAAtC,EAA0C;AACxC,EAAA,OAAOA,UAAU,CAACsD,KAAX,CAAiBzD,YAAjB,CAAP;AACD;;AACD,MAAM0D,cAAc,GAAG,CACrB;AAAEC,EAAAA,CAAC,EAAE,WAAL;AAAkBC,EAAAA,CAAC,EAAE;AAArB,CADqB,EAErB;AAAED,EAAAA,CAAC,EAAE,UAAL;AAAiBC,EAAAA,CAAC,EAAE;AAApB,CAFqB,CAAvB;;AAKA,MAAMC,QAAQ,GAAIC,CAAD,IAAOzD,MAAM,CAACwD,QAAP,CAAgBC,CAAhB,EAAmBJ,cAAc,CAACK,MAAf,CAAsB1D,MAAM,CAACwD,QAAP,CAAgBG,KAAtC,CAAnB,CAAxB;;;AAEA,MAAMC,cAAc,GAAG,CAACC,QAAD,EAAWC,QAAX,EAAqBC,OAAO,GAAG,EAA/B,KAAsC;AAC3D,EAAA,MAAM;AACJ;AACA;AACAC,IAAAA,aAHI;AAIJvD,IAAAA,OAJI;AAIK;AACTwD,IAAAA,OALI;;AAAA,GAAA,GAMFF,OANJ;AAQA,EAAA,IAAIG,aAAa,GAAGL,QAApB;AACA,EAAA,IAAIM,aAAa,GAAGL,QAApB;;AAEA,EAAA,IAAIE,aAAa,KAAK,KAAtB,EAA6B;AAC3B,IAAA,IAAIb,eAAe,CAACU,QAAD,CAAf,IAA6BV,eAAe,CAACW,QAAD,CAAhD,EAA4D;AAC1D,MAAA,OAAO,KAAP;AACD,IAAA;AACF,EAAA,CAJD,MAIO,IAAIE,aAAa,KAAK,IAAtB,EAA4B;AACjC,IAAA,IAAIb,eAAe,CAACU,QAAD,CAAf,IAA6BjE,uCAAuC,CAACwE,IAAxC,CAA6CP,QAA7C,CAAjC,EAAyF;AACvFK,MAAAA,aAAa,GAAGL,QAAQ,CAACjD,OAAT,CAAiBlB,iBAAjB,EAAoC,EAApC,CAAhB;AACD,IAAA;;AAED,IAAA,IAAIyD,eAAe,CAACW,QAAD,CAAf,IAA6BlE,uCAAuC,CAACwE,IAAxC,CAA6CN,QAA7C,CAAjC,EAAyF;AACvFK,MAAAA,aAAa,GAAGL,QAAQ,CAAClD,OAAT,CAAiBlB,iBAAjB,EAAoC,EAApC,CAAhB;AACD,IAAA;AACF,EAAA;;AAED,EAAA,MAAM2E,gBAAgB,GAAG9D,iBAAiB,CAAC2D,aAAD,EAAgBzD,OAAhB,CAA1C;AACA,EAAA,MAAM6D,gBAAgB,GAAG/D,iBAAiB,CAAC4D,aAAD,EAAgB1D,OAAhB,CAA1C;AAEA,EAAA,IAAI8D,GAAG,GAAG9B,2BAA2B,CAAC4B,gBAAD,CAA3B,GAAgDrE,MAAM,CAACD,WAAP,CAAmBsE,gBAAnB,CAAhD,GAAuFA,gBAAjG;AACA,EAAA,IAAIG,GAAG,GAAG/B,2BAA2B,CAAC6B,gBAAD,CAA3B,GAAgDtE,MAAM,CAACD,WAAP,CAAmBuE,gBAAnB,CAAhD,GAAuFA,gBAAjG;AAEAC,EAAAA,GAAG,GAAGf,QAAQ,CAACe,GAAD,CAAd;AACAC,EAAAA,GAAG,GAAGhB,QAAQ,CAACgB,GAAD,CAAd;AAEA,EAAA,MAAMC,MAAM,GAAGF,GAAG,CAACE,MAAJ,CAAWD,GAAX,CAAf;AAEA,EAAA,OAAOP,OAAO,GAAG,CAACQ,MAAJ,GAAaA,MAA3B;AACD;;MAEYC,GAAG,GAAG,CAACC,CAAD,EAAIC,CAAJ,KAAU;AAC3B,EAAA,MAAMC,EAAE,GAAG7E,MAAM,CAACC,KAAP,CAAa0E,CAAb,CAAX;AACA,EAAA,MAAMG,EAAE,GAAG9E,MAAM,CAACC,KAAP,CAAa2E,CAAb,CAAX;AAEA,EAAA,MAAMG,GAAG,GAAGvB,QAAQ,CAACqB,EAAD,CAApB;AACA,EAAA,MAAMG,GAAG,GAAGxB,QAAQ,CAACsB,EAAD,CAApB;AACA,EAAA,OAAOC,GAAG,CAACN,MAAJ,CAAWO,GAAX,CAAP;AACD;;;;"}

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "2.17.1-next.0+a5d1550f",
+  "version": "2.18.1",
   "description": "Math evaluator tool for comparing expressions for equality",
   "keywords": [
     "math",
@@ -23,8 +23,15 @@
     "mathjs": "^7.0.1"
   },
   "devDependencies": {
-    "@pie-lib/test-utils": "^0.18.1-next.0+a5d1550f"
+    "@pie-lib/test-utils": "^0.19.1"
   },
   "scripts": {},
-  "gitHead": "a5d1550faec7e27c8824e5aa4b4ef29ad4ee525a"
+  "gitHead": "be0b7951407a81d53b8b8b4861b8407b31728809",
+  "exports": {
+    ".": {
+      "import": "./esm/index.js",
+      "require": "./lib/index.js",
+      "default": "./esm/index.js"
+    }
+  }
 }