mathjs 11.2.0 → 11.3.0

package/lib/esm/core/function/import.js

@@ -61,15 +61,12 @@ export function importFactory(typed, load, math, importedFactories) {
    */
   function mathImport(functions, options) {
     var num = arguments.length;
-
     if (num !== 1 && num !== 2) {
       throw new ArgumentsError('import', num, 1, 2);
     }
-
     if (!options) {
       options = {};
     }
-
     function flattenImports(flatValues, value, name) {
       if (Array.isArray(value)) {
         value.forEach(item => flattenImports(flatValues, item));
@@ -81,12 +78,12 @@ export function importFactory(typed, load, math, importedFactories) {
         }
       } else if (isFactory(value) || name !== undefined) {
         var flatName = isFactory(value) ? isTransformFunctionFactory(value) ? value.fn + '.transform' // TODO: this is ugly
-        : value.fn : name; // we allow importing the same function twice if it points to the same implementation
+        : value.fn : name;
 
+        // we allow importing the same function twice if it points to the same implementation
         if (hasOwnProperty(flatValues, flatName) && flatValues[flatName] !== value && !options.silent) {
           throw new Error('Cannot import "' + flatName + '" twice');
         }
-
         flatValues[flatName] = value;
       } else {
         if (!options.silent) {
@@ -94,15 +91,12 @@ export function importFactory(typed, load, math, importedFactories) {
         }
       }
     }
-
     var flatValues = {};
     flattenImports(flatValues, functions);
-
     for (var name in flatValues) {
       if (hasOwnProperty(flatValues, name)) {
         // console.log('import', name)
         var value = flatValues[name];
-
         if (isFactory(value)) {
           // we ignore name here and enforce the name of the factory
           // maybe at some point we do want to allow overriding it
@@ -118,6 +112,7 @@ export function importFactory(typed, load, math, importedFactories) {
       }
     }
   }
+
   /**
    * Add a property to the math namespace
    * @param {string} name
@@ -125,22 +120,19 @@ export function importFactory(typed, load, math, importedFactories) {
    * @param {Object} options  See import for a description of the options
    * @private
    */
-
-
   function _import(name, value, options) {
     // TODO: refactor this function, it's to complicated and contains duplicate code
     if (options.wrap && typeof value === 'function') {
       // create a wrapper around the function
       value = _wrap(value);
-    } // turn a plain function with a typed-function signature into a typed-function
-
+    }
 
+    // turn a plain function with a typed-function signature into a typed-function
     if (hasTypedFunctionSignature(value)) {
       value = typed(name, {
         [value.signature]: value
       });
     }
-
     if (typed.isTypedFunction(math[name]) && typed.isTypedFunction(value)) {
       if (options.override) {
         // give the typed function the right name
@@ -149,61 +141,50 @@ export function importFactory(typed, load, math, importedFactories) {
         // merge the existing and typed function
         value = typed(math[name], value);
       }
-
       math[name] = value;
       delete importedFactories[name];
-
       _importTransform(name, value);
-
       math.emit('import', name, function resolver() {
         return value;
       });
       return;
     }
-
     if (math[name] === undefined || options.override) {
       math[name] = value;
       delete importedFactories[name];
-
       _importTransform(name, value);
-
       math.emit('import', name, function resolver() {
         return value;
       });
       return;
     }
-
     if (!options.silent) {
       throw new Error('Cannot import "' + name + '": already exists');
     }
   }
-
   function _importTransform(name, value) {
     if (value && typeof value.transform === 'function') {
       math.expression.transform[name] = value.transform;
-
       if (allowedInExpressions(name)) {
         math.expression.mathWithTransform[name] = value.transform;
       }
     } else {
       // remove existing transform
       delete math.expression.transform[name];
-
       if (allowedInExpressions(name)) {
         math.expression.mathWithTransform[name] = value;
       }
     }
   }
-
   function _deleteTransform(name) {
     delete math.expression.transform[name];
-
     if (allowedInExpressions(name)) {
       math.expression.mathWithTransform[name] = math[name];
     } else {
       delete math.expression.mathWithTransform[name];
     }
   }
+
   /**
    * Create a wrapper a round an function which converts the arguments
    * to their primitive values (like convert a Matrix to Array)
@@ -211,26 +192,21 @@ export function importFactory(typed, load, math, importedFactories) {
    * @return {Function} Returns the wrapped function
    * @private
    */
-
-
   function _wrap(fn) {
     var wrapper = function wrapper() {
       var args = [];
-
       for (var i = 0, len = arguments.length; i < len; i++) {
         var arg = arguments[i];
         args[i] = arg && arg.valueOf();
       }
-
       return fn.apply(math, args);
     };
-
     if (fn.transform) {
       wrapper.transform = fn.transform;
     }
-
     return wrapper;
   }
+
   /**
    * Import an instance of a factory into math.js
    * @param {function(scope: object)} factory
@@ -238,19 +214,14 @@ export function importFactory(typed, load, math, importedFactories) {
    * @param {string} [name=factory.name] Optional custom name
    * @private
    */
-
-
   function _importFactory(factory, options) {
     var name = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : factory.fn;
-
     if (contains(name, '.')) {
       throw new Error('Factory name should not contain a nested path. ' + 'Name: ' + JSON.stringify(name));
     }
-
     var namespace = isTransformFunctionFactory(factory) ? math.expression.transform : math;
     var existingTransform = (name in math.expression.transform);
     var existing = hasOwnProperty(namespace, name) ? namespace[name] : undefined;
-
     var resolver = function resolver() {
       // collect all dependencies, handle finding both functions and classes and other special cases
       var dependencies = {};
@@ -258,7 +229,6 @@ export function importFactory(typed, load, math, importedFactories) {
         if (contains(dependency, '.')) {
           throw new Error('Factory dependency should not contain a nested path. ' + 'Name: ' + JSON.stringify(dependency));
         }
-
         if (dependency === 'math') {
           dependencies.math = math;
         } else if (dependency === 'mathWithTransform') {
@@ -271,32 +241,29 @@ export function importFactory(typed, load, math, importedFactories) {
         }
       });
       var instance = /* #__PURE__ */factory(dependencies);
-
       if (instance && typeof instance.transform === 'function') {
         throw new Error('Transforms cannot be attached to factory functions. ' + 'Please create a separate function for it with exports.path="expression.transform"');
       }
-
       if (existing === undefined || options.override) {
         return instance;
       }
-
       if (typed.isTypedFunction(existing) && typed.isTypedFunction(instance)) {
         // merge the existing and new typed function
         return typed(existing, instance);
       }
-
       if (options.silent) {
         // keep existing, ignore imported function
         return existing;
       } else {
         throw new Error('Cannot import "' + name + '": already exists');
       }
-    }; // TODO: add unit test with non-lazy factory
-
+    };
 
+    // TODO: add unit test with non-lazy factory
     if (!factory.meta || factory.meta.lazy !== false) {
-      lazy(namespace, name, resolver); // FIXME: remove the `if (existing &&` condition again. Can we make sure subset is loaded before subset.transform? (Name collision, and no dependencies between the two)
+      lazy(namespace, name, resolver);
 
+      // FIXME: remove the `if (existing &&` condition again. Can we make sure subset is loaded before subset.transform? (Name collision, and no dependencies between the two)
       if (existing && existingTransform) {
         _deleteTransform(name);
       } else {
@@ -305,8 +272,9 @@ export function importFactory(typed, load, math, importedFactories) {
         }
       }
     } else {
-      namespace[name] = resolver(); // FIXME: remove the `if (existing &&` condition again. Can we make sure subset is loaded before subset.transform? (Name collision, and no dependencies between the two)
+      namespace[name] = resolver();
 
+      // FIXME: remove the `if (existing &&` condition again. Can we make sure subset is loaded before subset.transform? (Name collision, and no dependencies between the two)
       if (existing && existingTransform) {
         _deleteTransform(name);
       } else {
@@ -314,42 +282,38 @@ export function importFactory(typed, load, math, importedFactories) {
           lazy(math.expression.mathWithTransform, name, () => namespace[name]);
         }
       }
-    } // TODO: improve factories, store a list with imports instead which can be re-played
-
+    }
 
+    // TODO: improve factories, store a list with imports instead which can be re-played
     importedFactories[name] = factory;
     math.emit('import', name, resolver);
   }
+
   /**
    * Check whether given object is a type which can be imported
    * @param {Function | number | string | boolean | null | Unit | Complex} object
    * @return {boolean}
    * @private
    */
-
-
   function isSupportedType(object) {
     return typeof object === 'function' || typeof object === 'number' || typeof object === 'string' || typeof object === 'boolean' || object === null || isUnit(object) || isComplex(object) || isBigNumber(object) || isFraction(object) || isMatrix(object) || Array.isArray(object);
   }
-
   function hasTypedFunctionSignature(fn) {
     return typeof fn === 'function' && typeof fn.signature === 'string';
   }
-
   function allowedInExpressions(name) {
     return !hasOwnProperty(unsafe, name);
   }
-
   function factoryAllowedInExpressions(factory) {
-    return factory.fn.indexOf('.') === -1 && // FIXME: make checking on path redundant, check on meta data instead
+    return factory.fn.indexOf('.') === -1 &&
+    // FIXME: make checking on path redundant, check on meta data instead
     !hasOwnProperty(unsafe, factory.fn) && (!factory.meta || !factory.meta.isClass);
   }
-
   function isTransformFunctionFactory(factory) {
     return factory !== undefined && factory.meta !== undefined && factory.meta.isTransformFunction === true || false;
-  } // namespaces and functions not available in the parser for safety reasons
-
+  }
 
+  // namespaces and functions not available in the parser for safety reasons
   var unsafe = {
     expression: true,
     type: true,
@@ -357,7 +321,7 @@ export function importFactory(typed, load, math, importedFactories) {
     error: true,
     json: true,
     chain: true // chain method not supported. Note that there is a unit chain too.
-
   };
+
   return mathImport;
 }

package/lib/esm/core/function/typed.js

@@ -35,26 +35,27 @@
  * @param {Object<string, function>} signatures   Object with one or multiple function signatures
  * @returns {function} The created typed-function.
  */
+
 import { isAccessorNode, isArray, isArrayNode, isAssignmentNode, isBigNumber, isBlockNode, isBoolean, isChain, isCollection, isComplex, isConditionalNode, isConstantNode, isDate, isDenseMatrix, isFraction, isFunction, isFunctionAssignmentNode, isFunctionNode, isHelp, isIndex, isIndexNode, isMatrix, isNode, isNull, isNumber, isObject, isObjectNode, isOperatorNode, isParenthesisNode, isRange, isRangeNode, isRelationalNode, isRegExp, isResultSet, isSparseMatrix, isString, isSymbolNode, isUndefined, isUnit } from '../../utils/is.js';
 import typedFunction from 'typed-function';
 import { digits } from '../../utils/number.js';
 import { factory } from '../../utils/factory.js';
-import { isMap } from '../../utils/map.js'; // returns a new instance of typed-function
+import { isMap } from '../../utils/map.js';
 
+// returns a new instance of typed-function
 var _createTyped2 = function _createTyped() {
   // initially, return the original instance of typed-function
   // consecutively, return a new instance from typed.create.
   _createTyped2 = typedFunction.create;
   return typedFunction;
 };
-
 var dependencies = ['?BigNumber', '?Complex', '?DenseMatrix', '?Fraction'];
+
 /**
  * Factory function for creating a new typed instance
  * @param {Object} dependencies   Object with data types like Complex and BigNumber
  * @returns {Function}
  */
-
 export var createTyped = /* #__PURE__ */factory('typed', dependencies, function createTyped(_ref) {
   var {
     BigNumber,
@@ -62,14 +63,14 @@ export var createTyped = /* #__PURE__ */factory('typed', dependencies, function
     DenseMatrix,
     Fraction
   } = _ref;
-
   // TODO: typed-function must be able to silently ignore signatures with unknown data types
+
   // get a new instance of typed-function
-  var typed = _createTyped2(); // define all types. The order of the types determines in which order function
+  var typed = _createTyped2();
+
+  // define all types. The order of the types determines in which order function
   // arguments are type-checked (so for performance it's important to put the
   // most used types first).
-
-
   typed.clear();
   typed.addTypes([{
     name: 'number',
@@ -86,7 +87,8 @@ export var createTyped = /* #__PURE__ */factory('typed', dependencies, function
   }, {
     name: 'Unit',
     test: isUnit
-  }, // The following type matches a valid variable name, i.e., an alphanumeric
+  },
+  // The following type matches a valid variable name, i.e., an alphanumeric
   // string starting with an alphabetic character. It is used (at least)
   // in the definition of the derivative() function, as the argument telling
   // what to differentiate over must (currently) be a variable.
@@ -197,19 +199,19 @@ export var createTyped = /* #__PURE__ */factory('typed', dependencies, function
     test: isObject
   } // order 'Object' last, it matches on other classes too
   ]);
+
   typed.addConversions([{
     from: 'number',
     to: 'BigNumber',
     convert: function convert(x) {
       if (!BigNumber) {
         throwNoBignumber(x);
-      } // note: conversion from number to BigNumber can fail if x has >15 digits
-
+      }
 
+      // note: conversion from number to BigNumber can fail if x has >15 digits
       if (digits(x) > 15) {
         throw new TypeError('Cannot implicitly convert a number with >15 significant digits to BigNumber ' + '(value: ' + x + '). ' + 'Use function bignumber(x) to convert to BigNumber.');
       }
-
       return new BigNumber(x);
     }
   }, {
@@ -219,7 +221,6 @@ export var createTyped = /* #__PURE__ */factory('typed', dependencies, function
       if (!Complex) {
         throwNoComplex(x);
       }
-
       return new Complex(x, 0);
     }
   }, {
@@ -229,7 +230,6 @@ export var createTyped = /* #__PURE__ */factory('typed', dependencies, function
       if (!Complex) {
         throwNoComplex(x);
       }
-
       return new Complex(x.toNumber(), 0);
     }
   }, {
@@ -245,7 +245,6 @@ export var createTyped = /* #__PURE__ */factory('typed', dependencies, function
       if (!Complex) {
         throwNoComplex(x);
       }
-
       return new Complex(x.valueOf(), 0);
     }
   }, {
@@ -255,13 +254,10 @@ export var createTyped = /* #__PURE__ */factory('typed', dependencies, function
       if (!Fraction) {
         throwNoFraction(x);
       }
-
       var f = new Fraction(x);
-
       if (f.valueOf() !== x) {
         throw new TypeError('Cannot implicitly convert a number to a Fraction when there will be a loss of precision ' + '(value: ' + x + '). ' + 'Use function fraction(x) to convert to Fraction.');
       }
-
       return f;
     }
   }, {
@@ -276,11 +272,9 @@ export var createTyped = /* #__PURE__ */factory('typed', dependencies, function
     to: 'number',
     convert: function convert(x) {
       var n = Number(x);
-
       if (isNaN(n)) {
         throw new Error('Cannot convert "' + x + '" to a number');
       }
-
       return n;
     }
   }, {
@@ -290,7 +284,6 @@ export var createTyped = /* #__PURE__ */factory('typed', dependencies, function
       if (!BigNumber) {
         throwNoBignumber(x);
       }
-
       try {
         return new BigNumber(x);
       } catch (err) {
@@ -304,7 +297,6 @@ export var createTyped = /* #__PURE__ */factory('typed', dependencies, function
       if (!Fraction) {
         throwNoFraction(x);
       }
-
       try {
         return new Fraction(x);
       } catch (err) {
@@ -318,7 +310,6 @@ export var createTyped = /* #__PURE__ */factory('typed', dependencies, function
       if (!Complex) {
         throwNoComplex(x);
       }
-
       try {
         return new Complex(x);
       } catch (err) {
@@ -338,7 +329,6 @@ export var createTyped = /* #__PURE__ */factory('typed', dependencies, function
       if (!BigNumber) {
         throwNoBignumber(x);
       }
-
       return new BigNumber(+x);
     }
   }, {
@@ -348,7 +338,6 @@ export var createTyped = /* #__PURE__ */factory('typed', dependencies, function
       if (!Fraction) {
         throwNoFraction(x);
       }
-
       return new Fraction(+x);
     }
   }, {
@@ -364,7 +353,6 @@ export var createTyped = /* #__PURE__ */factory('typed', dependencies, function
       if (!DenseMatrix) {
         throwNoMatrix();
       }
-
       return new DenseMatrix(array);
     }
   }, {
@@ -373,56 +361,50 @@ export var createTyped = /* #__PURE__ */factory('typed', dependencies, function
     convert: function convert(matrix) {
       return matrix.valueOf();
     }
-  }]); // Provide a suggestion on how to call a function elementwise
+  }]);
+
+  // Provide a suggestion on how to call a function elementwise
   // This was added primarily as guidance for the v10 -> v11 transition,
   // and could potentially be removed in the future if it no longer seems
   // to be helpful.
-
   typed.onMismatch = (name, args, signatures) => {
     var usualError = typed.createError(name, args, signatures);
-
-    if (['wrongType', 'mismatch'].includes(usualError.data.category) && args.length === 1 && isCollection(args[0]) && // check if the function can be unary:
+    if (['wrongType', 'mismatch'].includes(usualError.data.category) && args.length === 1 && isCollection(args[0]) &&
+    // check if the function can be unary:
     signatures.some(sig => !sig.params.includes(','))) {
       var err = new TypeError("Function '".concat(name, "' doesn't apply to matrices. To call it ") + "elementwise on a matrix 'M', try 'map(M, ".concat(name, ")'."));
       err.data = usualError.data;
       throw err;
     }
-
     throw usualError;
-  }; // Provide a suggestion on how to call a function elementwise
+  };
+
+  // Provide a suggestion on how to call a function elementwise
   // This was added primarily as guidance for the v10 -> v11 transition,
   // and could potentially be removed in the future if it no longer seems
   // to be helpful.
-
-
   typed.onMismatch = (name, args, signatures) => {
     var usualError = typed.createError(name, args, signatures);
-
-    if (['wrongType', 'mismatch'].includes(usualError.data.category) && args.length === 1 && isCollection(args[0]) && // check if the function can be unary:
+    if (['wrongType', 'mismatch'].includes(usualError.data.category) && args.length === 1 && isCollection(args[0]) &&
+    // check if the function can be unary:
     signatures.some(sig => !sig.params.includes(','))) {
       var err = new TypeError("Function '".concat(name, "' doesn't apply to matrices. To call it ") + "elementwise on a matrix 'M', try 'map(M, ".concat(name, ")'."));
       err.data = usualError.data;
       throw err;
     }
-
     throw usualError;
   };
-
   return typed;
 });
-
 function throwNoBignumber(x) {
   throw new Error("Cannot convert value ".concat(x, " into a BigNumber: no class 'BigNumber' provided"));
 }
-
 function throwNoComplex(x) {
   throw new Error("Cannot convert value ".concat(x, " into a Complex number: no class 'Complex' provided"));
 }
-
 function throwNoMatrix() {
   throw new Error('Cannot convert array into a Matrix: no class \'DenseMatrix\' provided');
 }
-
 function throwNoFraction(x) {
   throw new Error("Cannot convert value ".concat(x, " into a Fraction, no class 'Fraction' provided."));
 }

package/lib/esm/entry/configReadonly.js

@@ -1,15 +1,14 @@
 import _extends from "@babel/runtime/helpers/extends";
 import { DEFAULT_CONFIG } from '../core/config.js';
-import { MATRIX_OPTIONS, NUMBER_OPTIONS } from '../core/function/config.js'; // create a read-only version of config
+import { MATRIX_OPTIONS, NUMBER_OPTIONS } from '../core/function/config.js';
 
+// create a read-only version of config
 export var config = /* #__PURE__ */function config(options) {
   if (options) {
     throw new Error('The global config is readonly. \n' + 'Please create a mathjs instance if you want to change the default configuration. \n' + 'Example:\n' + '\n' + '  import { create, all } from \'mathjs\';\n' + '  const mathjs = create(all);\n' + '  mathjs.config({ number: \'BigNumber\' });\n');
   }
-
   return Object.freeze(DEFAULT_CONFIG);
 };
-
 _extends(config, DEFAULT_CONFIG, {
   MATRIX_OPTIONS,
   NUMBER_OPTIONS

package/lib/esm/entry/dependenciesAny.generated.js

@@ -272,7 +272,6 @@ export { rowDependencies } from './dependenciesAny/dependenciesRow.generated.js'
 export { rowTransformDependencies } from './dependenciesAny/dependenciesRowTransform.generated.js';
 export { rydbergDependencies } from './dependenciesAny/dependenciesRydberg.generated.js';
 export { SQRT1_2Dependencies } from './dependenciesAny/dependenciesSQRT1_2.generated.js'; // eslint-disable-line camelcase
-
 export { SQRT2Dependencies } from './dependenciesAny/dependenciesSQRT2.generated.js';
 export { sackurTetrodeDependencies } from './dependenciesAny/dependenciesSackurTetrode.generated.js';
 export { secDependencies } from './dependenciesAny/dependenciesSec.generated.js';

package/lib/esm/entry/dependenciesNumber.generated.js

@@ -163,7 +163,6 @@ export { rightArithShiftDependencies } from './dependenciesNumber/dependenciesRi
 export { rightLogShiftDependencies } from './dependenciesNumber/dependenciesRightLogShift.generated.js';
 export { roundDependencies } from './dependenciesNumber/dependenciesRound.generated.js';
 export { SQRT1_2Dependencies } from './dependenciesNumber/dependenciesSQRT1_2.generated.js'; // eslint-disable-line camelcase
-
 export { SQRT2Dependencies } from './dependenciesNumber/dependenciesSQRT2.generated.js';
 export { secDependencies } from './dependenciesNumber/dependenciesSec.generated.js';
 export { sechDependencies } from './dependenciesNumber/dependenciesSech.generated.js';

package/lib/esm/entry/impureFunctionsAny.generated.js

@@ -1,17 +1,15 @@
 import _extends from "@babel/runtime/helpers/extends";
-
 /**
  * THIS FILE IS AUTO-GENERATED
  * DON'T MAKE CHANGES HERE
  */
 import { config } from './configReadonly.js';
 import { createNode, createObjectNode, createOperatorNode, createParenthesisNode, createRelationalNode, createArrayNode, createBlockNode, createConditionalNode, createConstantNode, createRangeNode, createReviver, createChainClass, createFunctionAssignmentNode, createChain, createAccessorNode, createAssignmentNode, createIndexNode, createSymbolNode, createFunctionNode, createParse, createResolve, createSimplifyConstant, createCompile, createHelpClass, createLeafCount, createSimplifyCore, createEvaluate, createHelp, createParserClass, createParser, createSimplify, createSymbolicEqual, createDerivative, createRationalize, createFilterTransform, createForEachTransform, createMapTransform, createApplyTransform, createDiffTransform, createSubsetTransform, createConcatTransform, createMaxTransform, createMinTransform, createRangeTransform, createSumTransform, createCumSumTransform, createRowTransform, createColumnTransform, createIndexTransform, createMeanTransform, createVarianceTransform, createStdTransform } from '../factoriesAny.js';
-import { BigNumber, Complex, e, _false, fineStructure, Fraction, i, _Infinity, LN10, LOG10E, Matrix, _NaN, _null, phi, Range, ResultSet, SQRT1_2, // eslint-disable-line camelcase
+import { BigNumber, Complex, e, _false, fineStructure, Fraction, i, _Infinity, LN10, LOG10E, Matrix, _NaN, _null, phi, Range, ResultSet, SQRT1_2,
+// eslint-disable-line camelcase
 sackurTetrode, tau, _true, version, DenseMatrix, efimovFactor, LN2, pi, replacer, SQRT2, typed, unaryPlus, weakMixingAngle, abs, acos, acot, acsc, addScalar, arg, asech, asinh, atan, atanh, bignumber, bitNot, boolean, clone, combinations, complex, conj, cosh, coth, csc, cube, equalScalar, erf, exp, expm1, filter, forEach, format, getMatrixDataType, hex, im, isInteger, isNegative, isPositive, isZero, LOG2E, lgamma, log10, log2, map, multiplyScalar, not, number, oct, pickRandom, print, random, re, sec, sign, sin, SparseMatrix, splitUnit, square, string, tan, typeOf, acosh, acsch, apply, asec, bin, combinationsWithRep, cos, csch, isNaN, isPrime, randomInt, sech, sinh, sparse, sqrt, tanh, unaryMinus, acoth, cot, fraction, isNumeric, matrix, matrixFromFunction, mod, nthRoot, numeric, or, prod, reshape, size, smaller, squeeze, subset, subtract, to, transpose, xgcd, zeros, and, bitAnd, bitXor, cbrt, compare, compareText, concat, count, ctranspose, diag, divideScalar, dotDivide, equal, fft, flatten, gcd, hasNumericValue, hypot, ifft, kron, largerEq, leftShift, lsolve, matrixFromColumns, min, mode, nthRoots, ones, partitionSelect, resize, rightArithShift, round, smallerEq, unequal, usolve, xor, add, atan2, bitOr, catalan, compareNatural, cumsum, deepEqual, diff, dot, equalText, floor, identity, invmod, larger, log, lsolveAll, matrixFromRows, multiply, qr, range, rightLogShift, setSize, slu, sum, trace, usolveAll, asin, ceil, composition, cross, det, distance, dotMultiply, FibonacciHeap, fix, ImmutableDenseMatrix, Index, intersect, lcm, log1p, max, quantileSeq, row, setCartesian, setDistinct, setIsSubset, setPowerset, sort, column, index, inv, pinv, pow, setDifference, setMultiplicity, Spa, sqrtm, Unit, vacuumImpedance, wienDisplacement, atomicMass, bohrMagneton, boltzmann, conductanceQuantum, createUnit, deuteronMass, dotPow, electricConstant, elementaryCharge, expm, faraday, firstRadiation, gamma, gravitationConstant, hartreeEnergy, klitzing, loschmidt, magneticConstant, molarMass, molarPlanckConstant, neutronMass, nuclearMagneton, planckCharge, planckLength, planckTemperature, protonMass, reducedPlanckConstant, rydberg, setIntersect, speedOfLight, stefanBoltzmann, thomsonCrossSection, avogadro, bohrRadius, coulomb, divide, electronMass, factorial, gravity, inverseConductanceQuantum, lup, magneticFluxQuantum, molarMassC12, multinomial, permutations, planckMass, quantumOfCirculation, secondRadiation, stirlingS2, unit, bellNumbers, eigs, fermiCoupling, mean, molarVolume, planckConstant, setSymDifference, variance, classicalElectronRadius, lusolve, median, setUnion, std, gasConstant, mad, norm, rotationMatrix, kldivergence, rotate, planckTime } from './pureFunctionsAny.generated.js';
 var math = {}; // NOT pure!
-
 var mathWithTransform = {}; // NOT pure!
-
 var classes = {}; // NOT pure!
 
 export var Node = createNode({
@@ -251,7 +249,6 @@ export var rationalize = createRationalize({
   subtract,
   typed
 });
-
 _extends(math, {
   e,
   false: _false,
@@ -550,7 +547,6 @@ _extends(math, {
   planckTime,
   config
 });
-
 _extends(mathWithTransform, math, {
   filter: createFilterTransform({
     typed
@@ -650,7 +646,6 @@ _extends(mathWithTransform, math, {
     variance
   })
 });
-
 _extends(classes, {
   BigNumber,
   Complex,
@@ -685,6 +680,5 @@ _extends(classes, {
   Help,
   Parser
 });
-
 Chain.createProxy(math);
 export { embeddedDocs as docs } from '../expression/embeddedDocs/embeddedDocs.js';