@tachybase/plugin-evaluator-mathjs 1.3.20

package/dist/node_modules/mathjs/lib/cjs/entry/typeChecks.js

@@ -0,0 +1,235 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "isAccessorNode", {
+  enumerable: true,
+  get: function get() {
+    return _is.isAccessorNode;
+  }
+});
+Object.defineProperty(exports, "isArray", {
+  enumerable: true,
+  get: function get() {
+    return _is.isArray;
+  }
+});
+Object.defineProperty(exports, "isArrayNode", {
+  enumerable: true,
+  get: function get() {
+    return _is.isArrayNode;
+  }
+});
+Object.defineProperty(exports, "isAssignmentNode", {
+  enumerable: true,
+  get: function get() {
+    return _is.isAssignmentNode;
+  }
+});
+Object.defineProperty(exports, "isBigNumber", {
+  enumerable: true,
+  get: function get() {
+    return _is.isBigNumber;
+  }
+});
+Object.defineProperty(exports, "isBlockNode", {
+  enumerable: true,
+  get: function get() {
+    return _is.isBlockNode;
+  }
+});
+Object.defineProperty(exports, "isBoolean", {
+  enumerable: true,
+  get: function get() {
+    return _is.isBoolean;
+  }
+});
+Object.defineProperty(exports, "isChain", {
+  enumerable: true,
+  get: function get() {
+    return _is.isChain;
+  }
+});
+Object.defineProperty(exports, "isCollection", {
+  enumerable: true,
+  get: function get() {
+    return _is.isCollection;
+  }
+});
+Object.defineProperty(exports, "isComplex", {
+  enumerable: true,
+  get: function get() {
+    return _is.isComplex;
+  }
+});
+Object.defineProperty(exports, "isConditionalNode", {
+  enumerable: true,
+  get: function get() {
+    return _is.isConditionalNode;
+  }
+});
+Object.defineProperty(exports, "isConstantNode", {
+  enumerable: true,
+  get: function get() {
+    return _is.isConstantNode;
+  }
+});
+Object.defineProperty(exports, "isDate", {
+  enumerable: true,
+  get: function get() {
+    return _is.isDate;
+  }
+});
+Object.defineProperty(exports, "isDenseMatrix", {
+  enumerable: true,
+  get: function get() {
+    return _is.isDenseMatrix;
+  }
+});
+Object.defineProperty(exports, "isFraction", {
+  enumerable: true,
+  get: function get() {
+    return _is.isFraction;
+  }
+});
+Object.defineProperty(exports, "isFunction", {
+  enumerable: true,
+  get: function get() {
+    return _is.isFunction;
+  }
+});
+Object.defineProperty(exports, "isFunctionAssignmentNode", {
+  enumerable: true,
+  get: function get() {
+    return _is.isFunctionAssignmentNode;
+  }
+});
+Object.defineProperty(exports, "isFunctionNode", {
+  enumerable: true,
+  get: function get() {
+    return _is.isFunctionNode;
+  }
+});
+Object.defineProperty(exports, "isHelp", {
+  enumerable: true,
+  get: function get() {
+    return _is.isHelp;
+  }
+});
+Object.defineProperty(exports, "isIndex", {
+  enumerable: true,
+  get: function get() {
+    return _is.isIndex;
+  }
+});
+Object.defineProperty(exports, "isIndexNode", {
+  enumerable: true,
+  get: function get() {
+    return _is.isIndexNode;
+  }
+});
+Object.defineProperty(exports, "isMatrix", {
+  enumerable: true,
+  get: function get() {
+    return _is.isMatrix;
+  }
+});
+Object.defineProperty(exports, "isNode", {
+  enumerable: true,
+  get: function get() {
+    return _is.isNode;
+  }
+});
+Object.defineProperty(exports, "isNull", {
+  enumerable: true,
+  get: function get() {
+    return _is.isNull;
+  }
+});
+Object.defineProperty(exports, "isNumber", {
+  enumerable: true,
+  get: function get() {
+    return _is.isNumber;
+  }
+});
+Object.defineProperty(exports, "isObject", {
+  enumerable: true,
+  get: function get() {
+    return _is.isObject;
+  }
+});
+Object.defineProperty(exports, "isObjectNode", {
+  enumerable: true,
+  get: function get() {
+    return _is.isObjectNode;
+  }
+});
+Object.defineProperty(exports, "isOperatorNode", {
+  enumerable: true,
+  get: function get() {
+    return _is.isOperatorNode;
+  }
+});
+Object.defineProperty(exports, "isParenthesisNode", {
+  enumerable: true,
+  get: function get() {
+    return _is.isParenthesisNode;
+  }
+});
+Object.defineProperty(exports, "isRange", {
+  enumerable: true,
+  get: function get() {
+    return _is.isRange;
+  }
+});
+Object.defineProperty(exports, "isRangeNode", {
+  enumerable: true,
+  get: function get() {
+    return _is.isRangeNode;
+  }
+});
+Object.defineProperty(exports, "isRegExp", {
+  enumerable: true,
+  get: function get() {
+    return _is.isRegExp;
+  }
+});
+Object.defineProperty(exports, "isResultSet", {
+  enumerable: true,
+  get: function get() {
+    return _is.isResultSet;
+  }
+});
+Object.defineProperty(exports, "isSparseMatrix", {
+  enumerable: true,
+  get: function get() {
+    return _is.isSparseMatrix;
+  }
+});
+Object.defineProperty(exports, "isString", {
+  enumerable: true,
+  get: function get() {
+    return _is.isString;
+  }
+});
+Object.defineProperty(exports, "isSymbolNode", {
+  enumerable: true,
+  get: function get() {
+    return _is.isSymbolNode;
+  }
+});
+Object.defineProperty(exports, "isUndefined", {
+  enumerable: true,
+  get: function get() {
+    return _is.isUndefined;
+  }
+});
+Object.defineProperty(exports, "isUnit", {
+  enumerable: true,
+  get: function get() {
+    return _is.isUnit;
+  }
+});
+
+var _is = require("../utils/is.js");

package/dist/node_modules/mathjs/lib/cjs/error/ArgumentsError.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ArgumentsError = ArgumentsError;
+
+/**
+ * Create a syntax error with the message:
+ *     'Wrong number of arguments in function <fn> (<count> provided, <min>-<max> expected)'
+ * @param {string} fn     Function name
+ * @param {number} count  Actual argument count
+ * @param {number} min    Minimum required argument count
+ * @param {number} [max]  Maximum required argument count
+ * @extends Error
+ */
+function ArgumentsError(fn, count, min, max) {
+  if (!(this instanceof ArgumentsError)) {
+    throw new SyntaxError('Constructor must be called with the new operator');
+  }
+
+  this.fn = fn;
+  this.count = count;
+  this.min = min;
+  this.max = max;
+  this.message = 'Wrong number of arguments in function ' + fn + ' (' + count + ' provided, ' + min + (max !== undefined && max !== null ? '-' + max : '') + ' expected)';
+  this.stack = new Error().stack;
+}
+
+ArgumentsError.prototype = new Error();
+ArgumentsError.prototype.constructor = Error;
+ArgumentsError.prototype.name = 'ArgumentsError';
+ArgumentsError.prototype.isArgumentsError = true;

package/dist/node_modules/mathjs/lib/cjs/error/DimensionError.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DimensionError = DimensionError;
+
+/**
+ * Create a range error with the message:
+ *     'Dimension mismatch (<actual size> != <expected size>)'
+ * @param {number | number[]} actual        The actual size
+ * @param {number | number[]} expected      The expected size
+ * @param {string} [relation='!=']          Optional relation between actual
+ *                                          and expected size: '!=', '<', etc.
+ * @extends RangeError
+ */
+function DimensionError(actual, expected, relation) {
+  if (!(this instanceof DimensionError)) {
+    throw new SyntaxError('Constructor must be called with the new operator');
+  }
+
+  this.actual = actual;
+  this.expected = expected;
+  this.relation = relation;
+  this.message = 'Dimension mismatch (' + (Array.isArray(actual) ? '[' + actual.join(', ') + ']' : actual) + ' ' + (this.relation || '!=') + ' ' + (Array.isArray(expected) ? '[' + expected.join(', ') + ']' : expected) + ')';
+  this.stack = new Error().stack;
+}
+
+DimensionError.prototype = new RangeError();
+DimensionError.prototype.constructor = RangeError;
+DimensionError.prototype.name = 'DimensionError';
+DimensionError.prototype.isDimensionError = true;

package/dist/node_modules/mathjs/lib/cjs/error/IndexError.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.IndexError = IndexError;
+
+/**
+ * Create a range error with the message:
+ *     'Index out of range (index < min)'
+ *     'Index out of range (index < max)'
+ *
+ * @param {number} index     The actual index
+ * @param {number} [min=0]   Minimum index (included)
+ * @param {number} [max]     Maximum index (excluded)
+ * @extends RangeError
+ */
+function IndexError(index, min, max) {
+  if (!(this instanceof IndexError)) {
+    throw new SyntaxError('Constructor must be called with the new operator');
+  }
+
+  this.index = index;
+
+  if (arguments.length < 3) {
+    this.min = 0;
+    this.max = min;
+  } else {
+    this.min = min;
+    this.max = max;
+  }
+
+  if (this.min !== undefined && this.index < this.min) {
+    this.message = 'Index out of range (' + this.index + ' < ' + this.min + ')';
+  } else if (this.max !== undefined && this.index >= this.max) {
+    this.message = 'Index out of range (' + this.index + ' > ' + (this.max - 1) + ')';
+  } else {
+    this.message = 'Index out of range (' + this.index + ')';
+  }
+
+  this.stack = new Error().stack;
+}
+
+IndexError.prototype = new RangeError();
+IndexError.prototype.constructor = RangeError;
+IndexError.prototype.name = 'IndexError';
+IndexError.prototype.isIndexError = true;

package/dist/node_modules/mathjs/lib/cjs/expression/Help.js

@@ -0,0 +1,145 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createHelpClass = void 0;
+
+var _is = require("../utils/is.js");
+
+var _object = require("../utils/object.js");
+
+var _string = require("../utils/string.js");
+
+var _factory = require("../utils/factory.js");
+
+var name = 'Help';
+var dependencies = ['parse'];
+var createHelpClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var parse = _ref.parse;
+
+  /**
+   * Documentation object
+   * @param {Object} doc  Object containing properties:
+   *                      {string} name
+   *                      {string} category
+   *                      {string} description
+   *                      {string[]} syntax
+   *                      {string[]} examples
+   *                      {string[]} seealso
+   * @constructor
+   */
+  function Help(doc) {
+    if (!(this instanceof Help)) {
+      throw new SyntaxError('Constructor must be called with the new operator');
+    }
+
+    if (!doc) throw new Error('Argument "doc" missing');
+    this.doc = doc;
+  }
+  /**
+   * Attach type information
+   */
+
+
+  Help.prototype.type = 'Help';
+  Help.prototype.isHelp = true;
+  /**
+   * Generate a string representation of the Help object
+   * @return {string} Returns a string
+   * @private
+   */
+
+  Help.prototype.toString = function () {
+    var doc = this.doc || {};
+    var desc = '\n';
+
+    if (doc.name) {
+      desc += 'Name: ' + doc.name + '\n\n';
+    }
+
+    if (doc.category) {
+      desc += 'Category: ' + doc.category + '\n\n';
+    }
+
+    if (doc.description) {
+      desc += 'Description:\n    ' + doc.description + '\n\n';
+    }
+
+    if (doc.syntax) {
+      desc += 'Syntax:\n    ' + doc.syntax.join('\n    ') + '\n\n';
+    }
+
+    if (doc.examples) {
+      desc += 'Examples:\n';
+      var scope = {};
+
+      for (var i = 0; i < doc.examples.length; i++) {
+        var expr = doc.examples[i];
+        desc += '    ' + expr + '\n';
+        var res = void 0;
+
+        try {
+          // note: res can be undefined when `expr` is an empty string
+          res = parse(expr).compile().evaluate(scope);
+        } catch (e) {
+          res = e;
+        }
+
+        if (res !== undefined && !(0, _is.isHelp)(res)) {
+          desc += '        ' + (0, _string.format)(res, {
+            precision: 14
+          }) + '\n';
+        }
+      }
+
+      desc += '\n';
+    }
+
+    if (doc.mayThrow && doc.mayThrow.length) {
+      desc += 'Throws: ' + doc.mayThrow.join(', ') + '\n\n';
+    }
+
+    if (doc.seealso && doc.seealso.length) {
+      desc += 'See also: ' + doc.seealso.join(', ') + '\n';
+    }
+
+    return desc;
+  };
+  /**
+   * Export the help object to JSON
+   */
+
+
+  Help.prototype.toJSON = function () {
+    var obj = (0, _object.clone)(this.doc);
+    obj.mathjs = 'Help';
+    return obj;
+  };
+  /**
+   * Instantiate a Help object from a JSON object
+   * @param {Object} json
+   * @returns {Help} Returns a new Help object
+   */
+
+
+  Help.fromJSON = function (json) {
+    var doc = {};
+    Object.keys(json).filter(function (prop) {
+      return prop !== 'mathjs';
+    }).forEach(function (prop) {
+      doc[prop] = json[prop];
+    });
+    return new Help(doc);
+  };
+  /**
+   * Returns a string representation of the Help object
+   */
+
+
+  Help.prototype.valueOf = Help.prototype.toString;
+  return Help;
+}, {
+  isClass: true
+});
+exports.createHelpClass = createHelpClass;

package/dist/node_modules/mathjs/lib/cjs/expression/Parser.js

@@ -0,0 +1,159 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createParserClass = void 0;
+
+var _factory = require("../utils/factory.js");
+
+var _map = require("../utils/map.js");
+
+var name = 'Parser';
+var dependencies = ['evaluate'];
+var createParserClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var evaluate = _ref.evaluate;
+
+  /**
+   * @constructor Parser
+   * Parser contains methods to evaluate or parse expressions, and has a number
+   * of convenience methods to get, set, and remove variables from memory. Parser
+   * keeps a scope containing variables in memory, which is used for all
+   * evaluations.
+   *
+   * Methods:
+   *    const result = parser.evaluate(expr)  // evaluate an expression
+   *    const value = parser.get(name)        // retrieve a variable from the parser
+   *    const values = parser.getAll()        // retrieve all defined variables
+   *    parser.set(name, value)               // set a variable in the parser
+   *    parser.remove(name)                   // clear a variable from the
+   *                                          // parsers scope
+   *    parser.clear()                        // clear the parsers scope
+   *
+   * Example usage:
+   *    const parser = new Parser()
+   *    // Note: there is a convenience method which can be used instead:
+   *    // const parser = new math.parser()
+   *
+   *    // evaluate expressions
+   *    parser.evaluate('sqrt(3^2 + 4^2)')        // 5
+   *    parser.evaluate('sqrt(-4)')               // 2i
+   *    parser.evaluate('2 inch in cm')           // 5.08 cm
+   *    parser.evaluate('cos(45 deg)')            // 0.7071067811865476
+   *
+   *    // define variables and functions
+   *    parser.evaluate('x = 7 / 2')              // 3.5
+   *    parser.evaluate('x + 3')                  // 6.5
+   *    parser.evaluate('f(x, y) = x^y')          // f(x, y)
+   *    parser.evaluate('f(2, 3)')                // 8
+   *
+   *    // get and set variables and functions
+   *    const x = parser.get('x')                 // 7
+   *    const f = parser.get('f')                 // function
+   *    const g = f(3, 2)                         // 9
+   *    parser.set('h', 500)
+   *    const i = parser.evaluate('h / 2')        // 250
+   *    parser.set('hello', function (name) {
+   *        return 'hello, ' + name + '!'
+   *    })
+   *    parser.evaluate('hello("user")')          // "hello, user!"
+   *
+   *    // clear defined functions and variables
+   *    parser.clear()
+   *
+   */
+  function Parser() {
+    if (!(this instanceof Parser)) {
+      throw new SyntaxError('Constructor must be called with the new operator');
+    }
+
+    Object.defineProperty(this, 'scope', {
+      value: (0, _map.createEmptyMap)(),
+      writable: false
+    });
+  }
+  /**
+   * Attach type information
+   */
+
+
+  Parser.prototype.type = 'Parser';
+  Parser.prototype.isParser = true;
+  /**
+   * Parse and evaluate the given expression
+   * @param {string | string[]} expr   A string containing an expression,
+   *                                   for example "2+3", or a list with expressions
+   * @return {*} result     The result, or undefined when the expression was empty
+   * @throws {Error}
+   */
+
+  Parser.prototype.evaluate = function (expr) {
+    // TODO: validate arguments
+    return evaluate(expr, this.scope);
+  };
+  /**
+   * Get a variable (a function or variable) by name from the parsers scope.
+   * Returns undefined when not found
+   * @param {string} name
+   * @return {* | undefined} value
+   */
+
+
+  Parser.prototype.get = function (name) {
+    // TODO: validate arguments
+    if (this.scope.has(name)) {
+      return this.scope.get(name);
+    }
+  };
+  /**
+   * Get a map with all defined variables
+   * @return {Object} values
+   */
+
+
+  Parser.prototype.getAll = function () {
+    return (0, _map.toObject)(this.scope);
+  };
+  /**
+   * Get a map with all defined variables
+   * @return {Map} values
+   */
+
+
+  Parser.prototype.getAllAsMap = function () {
+    return this.scope;
+  };
+  /**
+   * Set a symbol (a function or variable) by name from the parsers scope.
+   * @param {string} name
+   * @param {* | undefined} value
+   */
+
+
+  Parser.prototype.set = function (name, value) {
+    this.scope.set(name, value);
+    return value;
+  };
+  /**
+   * Remove a variable from the parsers scope
+   * @param {string} name
+   */
+
+
+  Parser.prototype.remove = function (name) {
+    this.scope.delete(name);
+  };
+  /**
+   * Clear the scope with variables and functions
+   */
+
+
+  Parser.prototype.clear = function () {
+    this.scope.clear();
+  };
+
+  return Parser;
+}, {
+  isClass: true
+});
+exports.createParserClass = createParserClass;

package/dist/node_modules/mathjs/lib/cjs/expression/embeddedDocs/constants/Infinity.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.InfinityDocs = void 0;
+var InfinityDocs = {
+  name: 'Infinity',
+  category: 'Constants',
+  syntax: ['Infinity'],
+  description: 'Infinity, a number which is larger than the maximum number that can be handled by a floating point number.',
+  examples: ['Infinity', '1 / 0'],
+  seealso: []
+};
+exports.InfinityDocs = InfinityDocs;

package/dist/node_modules/mathjs/lib/cjs/expression/embeddedDocs/constants/LN10.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LN10Docs = void 0;
+var LN10Docs = {
+  name: 'LN10',
+  category: 'Constants',
+  syntax: ['LN10'],
+  description: 'Returns the natural logarithm of 10, approximately equal to 2.302',
+  examples: ['LN10', 'log(10)'],
+  seealso: []
+};
+exports.LN10Docs = LN10Docs;

package/dist/node_modules/mathjs/lib/cjs/expression/embeddedDocs/constants/LN2.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LN2Docs = void 0;
+var LN2Docs = {
+  name: 'LN2',
+  category: 'Constants',
+  syntax: ['LN2'],
+  description: 'Returns the natural logarithm of 2, approximately equal to 0.693',
+  examples: ['LN2', 'log(2)'],
+  seealso: []
+};
+exports.LN2Docs = LN2Docs;