@tachybase/plugin-evaluator-mathjs 1.3.20

package/dist/node_modules/mathjs/lib/esm/utils/snapshot.js

@@ -0,0 +1,275 @@
+import _extends from "@babel/runtime/helpers/extends";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+/**
+ * This file contains helper methods to create expected snapshot structures
+ * of both instance and ES6 exports.
+ *
+ * The files are located here and not under /test or /tools so it's transpiled
+ * into ES5 code under /lib and can be used straight by node.js
+ */
+import assert from 'assert';
+import * as allIsFunctions from './is.js';
+import { create } from '../core/create.js';
+import { endsWith } from './string.js';
+export function validateBundle(expectedBundleStructure, bundle) {
+  var originalWarn = console.warn;
+
+  console.warn = function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    if (args.join(' ').indexOf('is moved to') !== -1 && args.join(' ').indexOf('Please use the new location instead') !== -1) {
+      // Ignore warnings like:
+      // Warning: math.type.isNumber is moved to math.isNumber in v6.0.0. Please use the new location instead.
+      return;
+    }
+
+    originalWarn.apply(console, args);
+  };
+
+  try {
+    var issues = []; // see whether all expected functions and objects are there
+
+    traverse(expectedBundleStructure, (expectedType, path) => {
+      var actualValue = get(bundle, path);
+      var actualType = validateTypeOf(actualValue);
+      var message = actualType === 'undefined' ? 'Missing entry in bundle. ' + "Path: ".concat(JSON.stringify(path), ", expected type: ").concat(expectedType, ", actual type: ").concat(actualType) : 'Unexpected entry type in bundle. ' + "Path: ".concat(JSON.stringify(path), ", expected type: ").concat(expectedType, ", actual type: ").concat(actualType);
+
+      if (actualType !== expectedType) {
+        issues.push({
+          actualType,
+          expectedType,
+          message
+        });
+        console.warn(message);
+      }
+    }); // see whether there are any functions or objects that shouldn't be there
+
+    traverse(bundle, (actualValue, path) => {
+      var actualType = validateTypeOf(actualValue);
+      var expectedType = get(expectedBundleStructure, path) || 'undefined'; // FIXME: ugly to have these special cases
+
+      if (path.join('.').indexOf('docs.') !== -1) {
+        // ignore the contents of docs
+        return;
+      }
+
+      if (path.join('.').indexOf('all.') !== -1) {
+        // ignore the contents of all dependencies
+        return;
+      }
+
+      var message = expectedType === 'undefined' ? 'Unknown entry in bundle. ' + 'Is there a new function added which is missing in this snapshot test? ' + "Path: ".concat(JSON.stringify(path), ", expected type: ").concat(expectedType, ", actual type: ").concat(actualType) : 'Unexpected entry type in bundle. ' + "Path: ".concat(JSON.stringify(path), ", expected type: ").concat(expectedType, ", actual type: ").concat(actualType);
+
+      if (actualType !== expectedType) {
+        issues.push({
+          actualType,
+          expectedType,
+          message
+        });
+        console.warn(message);
+      }
+    }); // assert on the first issue (if any)
+
+    if (issues.length > 0) {
+      var {
+        actualType,
+        expectedType,
+        message
+      } = issues[0];
+      console.warn("".concat(issues.length, " bundle issues found"));
+      assert.strictEqual(actualType, expectedType, message);
+    }
+  } finally {
+    console.warn = originalWarn;
+  }
+}
+/**
+ * Based on an object with factory functions, create the expected
+ * structures for ES6 export and a mathjs instance.
+ * @param {Object} factories
+ * @return {{expectedInstanceStructure: Object, expectedES6Structure: Object}}
+ */
+
+export function createSnapshotFromFactories(factories) {
+  var math = create(factories);
+  var allFactoryFunctions = {};
+  var allFunctionsConstantsClasses = {};
+  var allFunctionsConstants = {};
+  var allTransformFunctions = {};
+  var allDependencyCollections = {};
+  var allClasses = {};
+  var allNodeClasses = {};
+  Object.keys(factories).forEach(factoryName => {
+    var factory = factories[factoryName];
+    var name = factory.fn;
+    var isTransformFunction = factory.meta && factory.meta.isTransformFunction;
+    var isClass = !isLowerCase(name[0]) && validateTypeOf(math[name]) === 'Function';
+    var dependenciesName = factory.fn + (isTransformFunction ? 'Transform' : '') + 'Dependencies';
+    allFactoryFunctions[factoryName] = 'Function';
+    allFunctionsConstantsClasses[name] = validateTypeOf(math[name]);
+    allDependencyCollections[dependenciesName] = 'Object';
+
+    if (isTransformFunction) {
+      allTransformFunctions[name] = 'Function';
+    }
+
+    if (isClass) {
+      if (endsWith(name, 'Node')) {
+        allNodeClasses[name] = 'Function';
+      } else {
+        allClasses[name] = 'Function';
+      }
+    } else {
+      allFunctionsConstants[name] = validateTypeOf(math[name]);
+    }
+  });
+  var embeddedDocs = {};
+  Object.keys(factories).forEach(factoryName => {
+    var factory = factories[factoryName];
+    var name = factory.fn;
+
+    if (isLowerCase(factory.fn[0])) {
+      // ignore class names starting with upper case
+      embeddedDocs[name] = 'Object';
+    }
+  });
+  embeddedDocs = exclude(embeddedDocs, ['equalScalar', 'apply', 'addScalar', 'multiplyScalar', 'print', 'divideScalar', 'parse', 'compile', 'parser', 'chain', 'reviver', 'replacer']);
+  var allTypeChecks = {};
+  Object.keys(allIsFunctions).forEach(name => {
+    if (name.indexOf('is') === 0) {
+      allTypeChecks[name] = 'Function';
+    }
+  });
+  var allErrorClasses = {
+    ArgumentsError: 'Function',
+    DimensionError: 'Function',
+    IndexError: 'Function'
+  };
+
+  var expectedInstanceStructure = _objectSpread(_objectSpread(_objectSpread(_objectSpread({}, allFunctionsConstantsClasses), {}, {
+    on: 'Function',
+    off: 'Function',
+    once: 'Function',
+    emit: 'Function',
+    import: 'Function',
+    config: 'Function',
+    create: 'Function',
+    factory: 'Function'
+  }, allTypeChecks), allErrorClasses), {}, {
+    expression: {
+      transform: _objectSpread({}, allTransformFunctions),
+      mathWithTransform: _objectSpread(_objectSpread({}, exclude(allFunctionsConstants, ['chain'])), {}, {
+        config: 'Function'
+      })
+    }
+  });
+
+  var expectedES6Structure = _objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread({}, exclude(allFunctionsConstantsClasses, ['E', 'false', 'Infinity', 'NaN', 'null', 'PI', 'true'])), {}, {
+    create: 'Function',
+    config: 'Function',
+    factory: 'Function',
+    _true: 'boolean',
+    _false: 'boolean',
+    _null: 'null',
+    _Infinity: 'number',
+    _NaN: 'number'
+  }, allTypeChecks), allErrorClasses), allDependencyCollections), allFactoryFunctions), {}, {
+    docs: embeddedDocs
+  });
+
+  return {
+    expectedInstanceStructure,
+    expectedES6Structure
+  };
+}
+export function validateTypeOf(x) {
+  if (x && x.type === 'Unit') {
+    return 'Unit';
+  }
+
+  if (x && x.type === 'Complex') {
+    return 'Complex';
+  }
+
+  if (Array.isArray(x)) {
+    return 'Array';
+  }
+
+  if (x === null) {
+    return 'null';
+  }
+
+  if (typeof x === 'function') {
+    return 'Function';
+  }
+
+  if (typeof x === 'object') {
+    return 'Object';
+  }
+
+  return typeof x;
+}
+
+function traverse(obj) {
+  var callback = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : (value, path) => {};
+  var path = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+
+  // FIXME: ugly to have these special cases
+  if (path.length > 0 && path[0].indexOf('Dependencies') !== -1) {
+    // special case for objects holding a collection of dependencies
+    callback(obj, path);
+  } else if (validateTypeOf(obj) === 'Array') {
+    obj.map((item, index) => traverse(item, callback, path.concat(index)));
+  } else if (validateTypeOf(obj) === 'Object') {
+    Object.keys(obj).forEach(key => {
+      // FIXME: ugly to have these special cases
+      // ignore special case of deprecated docs
+      if (key === 'docs' && path.join('.') === 'expression') {
+        return;
+      }
+
+      traverse(obj[key], callback, path.concat(key));
+    });
+  } else {
+    callback(obj, path);
+  }
+}
+
+function get(object, path) {
+  var child = object;
+
+  for (var i = 0; i < path.length; i++) {
+    var key = path[i];
+    child = child ? child[key] : undefined;
+  }
+
+  return child;
+}
+/**
+ * Create a copy of the provided `object` and delete
+ * all properties listed in `excludedProperties`
+ * @param {Object} object
+ * @param {string[]} excludedProperties
+ * @return {Object}
+ */
+
+
+function exclude(object, excludedProperties) {
+  var strippedObject = _extends({}, object);
+
+  excludedProperties.forEach(excludedProperty => {
+    delete strippedObject[excludedProperty];
+  });
+  return strippedObject;
+}
+
+function isLowerCase(text) {
+  return typeof text === 'string' && text.toLowerCase() === text;
+}

package/dist/node_modules/mathjs/lib/esm/utils/string.js

@@ -0,0 +1,220 @@
+import { isBigNumber, isString, typeOf } from './is.js';
+import { format as formatNumber } from './number.js';
+import { format as formatBigNumber } from './bignumber/formatter.js';
+/**
+ * Check if a text ends with a certain string.
+ * @param {string} text
+ * @param {string} search
+ */
+
+export function endsWith(text, search) {
+  var start = text.length - search.length;
+  var end = text.length;
+  return text.substring(start, end) === search;
+}
+/**
+ * Format a value of any type into a string.
+ *
+ * Usage:
+ *     math.format(value)
+ *     math.format(value, precision)
+ *     math.format(value, options)
+ *
+ * When value is a function:
+ *
+ * - When the function has a property `syntax`, it returns this
+ *   syntax description.
+ * - In other cases, a string `'function'` is returned.
+ *
+ * When `value` is an Object:
+ *
+ * - When the object contains a property `format` being a function, this
+ *   function is invoked as `value.format(options)` and the result is returned.
+ * - When the object has its own `toString` method, this method is invoked
+ *   and the result is returned.
+ * - In other cases the function will loop over all object properties and
+ *   return JSON object notation like '{"a": 2, "b": 3}'.
+ *
+ * Example usage:
+ *     math.format(2/7)                // '0.2857142857142857'
+ *     math.format(math.pi, 3)         // '3.14'
+ *     math.format(new Complex(2, 3))  // '2 + 3i'
+ *     math.format('hello')            // '"hello"'
+ *
+ * @param {*} value             Value to be stringified
+ * @param {Object | number | Function} [options]
+ *     Formatting options. See src/utils/number.js:format for a
+ *     description of the available options controlling number output.
+ *     This generic "format" also supports the option property `truncate: NN`
+ *     giving the maximum number NN of characters to return (if there would
+ *     have been more, they are deleted and replaced by an ellipsis).
+ * @return {string} str
+ */
+
+export function format(value, options) {
+  var 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 formatNumber(value, options);
+  }
+
+  if (isBigNumber(value)) {
+    return formatBigNumber(value, options);
+  } // note: we use unsafe duck-typing here to check for Fractions, this is
+  // ok here since we're only invoking toString or concatenating its values
+
+
+  if (looksLikeFraction(value)) {
+    if (!options || options.fraction !== 'decimal') {
+      // output as ratio, like '1/3'
+      return value.s * value.n + '/' + value.d;
+    } else {
+      // output as decimal, like '0.(3)'
+      return value.toString();
+    }
+  }
+
+  if (Array.isArray(value)) {
+    return formatArray(value, options);
+  }
+
+  if (isString(value)) {
+    return '"' + value + '"';
+  }
+
+  if (typeof value === 'function') {
+    return value.syntax ? String(value.syntax) : 'function';
+  }
+
+  if (value && typeof value === 'object') {
+    if (typeof value.format === 'function') {
+      return value.format(options);
+    } else if (value && value.toString(options) !== {}.toString()) {
+      // this object has a non-native toString method, use that one
+      return value.toString(options);
+    } else {
+      var entries = Object.keys(value).map(key => {
+        return '"' + key + '": ' + format(value[key], options);
+      });
+      return '{' + entries.join(', ') + '}';
+    }
+  }
+
+  return String(value);
+}
+/**
+ * Stringify a value into a string enclosed in double quotes.
+ * Unescaped double quotes and backslashes inside the value are escaped.
+ * @param {*} value
+ * @return {string}
+ */
+
+
+export function stringify(value) {
+  var text = String(value);
+  var escaped = '';
+  var i = 0;
+
+  while (i < text.length) {
+    var c = text.charAt(i);
+
+    if (c === '\\') {
+      escaped += c;
+      i++;
+      c = text.charAt(i);
+
+      if (c === '' || '"\\/bfnrtu'.indexOf(c) === -1) {
+        escaped += '\\'; // no valid escape character -> escape it
+      }
+
+      escaped += c;
+    } else if (c === '"') {
+      escaped += '\\"';
+    } else {
+      escaped += c;
+    }
+
+    i++;
+  }
+
+  return '"' + escaped + '"';
+}
+/**
+ * Escape special HTML characters
+ * @param {*} value
+ * @return {string}
+ */
+
+export function escape(value) {
+  var text = String(value);
+  text = text.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/'/g, '&#39;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+  return text;
+}
+/**
+ * Recursively format an n-dimensional matrix
+ * Example output: "[[1, 2], [3, 4]]"
+ * @param {Array} array
+ * @param {Object | number | Function} [options]  Formatting options. See
+ *                                                lib/utils/number:format for a
+ *                                                description of the available
+ *                                                options.
+ * @returns {string} str
+ */
+
+function formatArray(array, options) {
+  if (Array.isArray(array)) {
+    var str = '[';
+    var len = array.length;
+
+    for (var i = 0; i < len; i++) {
+      if (i !== 0) {
+        str += ', ';
+      }
+
+      str += formatArray(array[i], options);
+    }
+
+    str += ']';
+    return str;
+  } else {
+    return format(array, options);
+  }
+}
+/**
+ * Check whether a value looks like a Fraction (unsafe duck-type check)
+ * @param {*} value
+ * @return {boolean}
+ */
+
+
+function looksLikeFraction(value) {
+  return value && typeof value === 'object' && typeof value.s === 'number' && typeof value.n === 'number' && typeof value.d === 'number' || false;
+}
+/**
+ * Compare two strings
+ * @param {string} x
+ * @param {string} y
+ * @returns {number}
+ */
+
+
+export function compareText(x, y) {
+  // we don't want to convert numbers to string, only accept string input
+  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;
+}

package/dist/node_modules/mathjs/lib/esm/utils/switch.js

@@ -0,0 +1,24 @@
+/**
+ * Transpose a matrix
+ * @param {Array} mat
+ * @returns {Array} ret
+ * @private
+ */
+export function _switch(mat) {
+  var I = mat.length;
+  var J = mat[0].length;
+  var i, j;
+  var ret = [];
+
+  for (j = 0; j < J; j++) {
+    var tmp = [];
+
+    for (i = 0; i < I; i++) {
+      tmp.push(mat[i][j]);
+    }
+
+    ret.push(tmp);
+  }
+
+  return ret;
+}

package/dist/node_modules/mathjs/lib/esm/version.js

@@ -0,0 +1,2 @@
+export var version = '10.6.4'; // Note: This file is automatically generated when building math.js.
+// Changes made in this file will be overwritten.

package/dist/node_modules/mathjs/main/es5/index.js

@@ -0,0 +1,3 @@
+// TODO: deprecated since v8, remove this deprecation warning in v9
+throw new Error('The file "mathjs/main/es5/index.js" has been moved since mathjs@8.0.0. ' +
+  'Please load "mathjs" or "mathjs/lib/cjs/index.js" instead.')

package/dist/node_modules/mathjs/main/es5/number.js

@@ -0,0 +1,3 @@
+// TODO: deprecated since v8, remove this deprecation warning in v9
+throw new Error('The file "mathjs/main/es5/number.js" has been moved since mathjs@8.0.0. ' +
+  'Please load "mathjs/number" or "mathjs/lib/cjs/number.js" instead.')

package/dist/node_modules/mathjs/main/es5/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/node_modules/mathjs/main/esm/index.js

@@ -0,0 +1,3 @@
+// TODO: deprecated since v8, remove this deprecation warning in v9
+throw new Error('The file "mathjs/main/esm/index.js" has been moved since mathjs@8.0.0. ' +
+  'Please load "mathjs" or "mathjs/lib/esm/index.js" instead.')

package/dist/node_modules/mathjs/main/esm/number.js

@@ -0,0 +1,3 @@
+// TODO: deprecated since v8, remove this deprecation warning in v9
+throw new Error('The file "mathjs/main/esm/number.js" has been moved since mathjs@8.0.0. ' +
+  'Please load "mathjs/number" or "mathjs/lib/esm/number.js" instead.')

package/dist/node_modules/mathjs/main/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/dist/node_modules/mathjs/number.cjs

@@ -0,0 +1,3 @@
+// TODO: deprecated since v8, remove this deprecation warning in v9
+throw new Error('The file "mathjs/number.js" has been moved since mathjs@8.0.0. ' +
+    'Please load "mathjs/number" or "mathjs/lib/esm/number.js" instead.')

package/dist/node_modules/mathjs/package.json

@@ -0,0 +1 @@
+{"name":"mathjs","version":"10.6.4","description":"Math.js is an extensive math library for JavaScript and Node.js. It features a flexible expression parser with support for symbolic computation, comes with a large set of built-in functions and constants, and offers an integrated solution to work with different data types like numbers, big numbers, complex numbers, fractions, units, and matrices.","author":"Jos de Jong <wjosdejong@gmail.com> (https://github.com/josdejong)","homepage":"https://mathjs.org","repository":{"type":"git","url":"https://github.com/josdejong/mathjs.git"},"license":"Apache-2.0","keywords":["math","mathematics","functions","numeric","algebra","parser","expression","number","bignumber","complex","fraction","matrix","unit"],"dependencies":{"@babel/runtime":"^7.18.6","complex.js":"^2.1.1","decimal.js":"^10.3.1","escape-latex":"^1.2.0","fraction.js":"^4.2.0","javascript-natural-sort":"^0.7.1","seedrandom":"^3.0.5","tiny-emitter":"^2.1.0","typed-function":"^2.1.0"},"devDependencies":{"@babel/core":"7.18.6","@babel/plugin-transform-object-assign":"7.18.6","@babel/plugin-transform-runtime":"7.18.6","@babel/preset-env":"7.18.6","@babel/register":"7.18.6","@types/assert":"1.5.6","@types/mocha":"9.1.1","@typescript-eslint/eslint-plugin":"5.30.0","@typescript-eslint/parser":"5.30.0","assert":"2.0.0","babel-loader":"8.2.5","benchmark":"2.1.4","codecov":"3.8.3","core-js":"3.23.3","del":"6.1.1","dtslint":"4.2.1","eslint":"8.18.0","eslint-config-prettier":"8.5.0","eslint-config-standard":"17.0.0","eslint-plugin-import":"2.26.0","eslint-plugin-mocha":"10.0.5","eslint-plugin-n":"15.2.3","eslint-plugin-prettier":"4.1.0","eslint-plugin-promise":"6.0.0","expect-type":"0.13.0","expr-eval":"2.0.2","fancy-log":"2.0.0","glob":"7.2.0","gulp":"4.0.2","gulp-babel":"8.0.0","handlebars":"4.7.7","istanbul":"0.4.5","jsep":"1.3.6","karma":"6.4.0","karma-browserstack-launcher":"1.6.0","karma-firefox-launcher":"2.1.2","karma-mocha":"2.0.1","karma-mocha-reporter":"2.2.5","karma-webpack":"4.0.2","math-expression-evaluator":"1.3.14","mkdirp":"1.0.4","mocha":"8.4.0","ndarray":"1.0.19","ndarray-determinant":"1.0.0","ndarray-gemm":"1.0.0","ndarray-ops":"1.2.2","ndarray-pack":"1.2.1","numericjs":"1.2.6","nyc":"15.1.0","pad-right":"0.2.2","prettier":"2.7.1","process":"0.11.10","sylvester":"0.0.21","ts-node":"10.8.1","typescript":"4.7.4","webpack":"4.46.0","zeros":"1.0.0"},"type":"module","main":"./lib/cjs","types":"./types/index.d.ts","module":"./lib/esm","unpkg":"./lib/browser/math.js","jsdelivr":"./lib/browser/math.js","exports":{".":{"types":"./types/index.d.ts","import":"./lib/esm/index.js","require":"./lib/cjs/index.js"},"./number":{"types":"./types/index.d.ts","import":"./lib/esm/number.js","require":"./lib/cjs/number.js"},"./lib/esm/number":{"types":"./types/index.d.ts","import":"./lib/esm/number.js","require":"./lib/cjs/number.js"},"./package.json":"./package.json","./lib/browser/math.js":"./lib/browser/math.js","./lib/browser/math.js.map":"./lib/browser/math.js.map","./dist/math.js":"./dist/math.js","./dist/math.min.js":"./dist/math.min.js","./main/es5/index.js":"./main/es5/index.js","./main/es5/number.js":"./main/es5/number.js","./main/esm/index.js":"./main/esm/index.js","./main/esm/number.js":"./main/esm/number.js","./number.js":"./number.cjs"},"files":["bin","dist","lib","main","types","number.cjs","LICENSE","NOTICE","README.md","HISTORY.md","CONTRIBUTING.md"],"directories":{"bin":"./bin","lib":"./lib"},"scripts":{"build":"gulp --gulpfile gulpfile.cjs && npm run update-authors","build-and-test":"npm run build && npm run test:all && npm run lint","build:clean":"gulp --gulpfile gulpfile.cjs clean","build:docs":"gulp --gulpfile gulpfile.cjs docs","compile":"gulp --gulpfile gulpfile.cjs compile","watch":"gulp --gulpfile gulpfile.cjs watch","lint":"eslint --cache --max-warnings 0 src/ test/ types/","format":"npm run lint -- --fix","validate:ascii":"gulp --gulpfile gulpfile.cjs validate:ascii","test":"npm run test:src && npm run lint","test:src":"mocha test/unit-tests","test:generated":"mocha test/generated-code-tests","test:node":"mocha test/node-tests/*.test.js test/node-tests/**/*.test.js","test:all":"npm run test:src && npm run test:generated && npm run test:node && npm run test:types","test:browser":"karma start test/browser-test-config/local-karma.js","test:browserstack":"karma start test/browser-test-config/browserstack-karma.js","test:types":"cd types && node --loader ts-node/esm ./index.ts","coverage":"nyc --reporter=lcov --reporter=text-summary mocha test/unit-tests && echo \"\nDetailed coverage report is available at ./coverage/lcov-report/index.html\"","prepublishOnly":"npm run test:all && npm run lint","prepare":"npm run build","update-authors":"node ./tools/update-authors.js"},"bin":{"mathjs":"./bin/cli.js"},"engines":{"node":">= 14"},"bugs":{"url":"https://github.com/josdejong/mathjs/issues"},"browserslist":["IE 11"],"sideEffects":false,"_lastModified":"2025-07-24T06:22:36.917Z"}