mathjs 9.5.0 → 10.0.1

package/lib/cjs/entry/impureFunctionsNumber.generated.js

@@ -5,13 +5,14 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.derivative = exports.compile = exports.chain = exports.SymbolNode = exports.RelationalNode = exports.RangeNode = exports.Parser = exports.ParenthesisNode = exports.OperatorNode = exports.ObjectNode = exports.Node = exports.IndexNode = exports.Help = exports.FunctionNode = exports.FunctionAssignmentNode = exports.ConstantNode = exports.ConditionalNode = exports.Chain = exports.BlockNode = exports.AssignmentNode = exports.ArrayNode = exports.AccessorNode = void 0;
 Object.defineProperty(exports, "docs", {
   enumerable: true,
   get: function get() {
     return _embeddedDocs.embeddedDocs;
   }
 });
-exports.parser = exports.derivative = exports.Parser = exports.help = exports.compile = exports.rationalize = exports.simplify = exports.Help = exports.evaluate = exports.parse = exports.IndexNode = exports.FunctionNode = exports.AssignmentNode = exports.RangeNode = exports.ConstantNode = exports.AccessorNode = exports.SymbolNode = exports.OperatorNode = exports.BlockNode = exports.reviver = exports.RelationalNode = exports.ParenthesisNode = exports.ObjectNode = exports.FunctionAssignmentNode = exports.ConditionalNode = exports.ArrayNode = exports.Node = exports.chain = exports.Chain = void 0;
+exports.simplify = exports.reviver = exports.rationalize = exports.parser = exports.parse = exports.help = exports.evaluate = void 0;
 
 var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
 
@@ -37,6 +38,10 @@ var Chain = (0, _factoriesNumber.createChainClass)({
   math: math
 });
 exports.Chain = Chain;
+var reviver = (0, _factoriesNumber.createReviver)({
+  classes: classes
+});
+exports.reviver = reviver;
 var chain = (0, _factoriesNumber.createChain)({
   Chain: Chain,
   typed: _pureFunctionsNumberGenerated.typed
@@ -46,44 +51,18 @@ var Node = (0, _factoriesNumber.createNode)({
   mathWithTransform: mathWithTransform
 });
 exports.Node = Node;
-var ArrayNode = (0, _factoriesNumber.createArrayNode)({
-  Node: Node
-});
-exports.ArrayNode = ArrayNode;
-var ConditionalNode = (0, _factoriesNumber.createConditionalNode)({
-  Node: Node
-});
-exports.ConditionalNode = ConditionalNode;
-var FunctionAssignmentNode = (0, _factoriesNumber.createFunctionAssignmentNode)({
-  Node: Node,
-  typed: _pureFunctionsNumberGenerated.typed
-});
-exports.FunctionAssignmentNode = FunctionAssignmentNode;
 var ObjectNode = (0, _factoriesNumber.createObjectNode)({
   Node: Node
 });
 exports.ObjectNode = ObjectNode;
-var ParenthesisNode = (0, _factoriesNumber.createParenthesisNode)({
+var RangeNode = (0, _factoriesNumber.createRangeNode)({
   Node: Node
 });
-exports.ParenthesisNode = ParenthesisNode;
+exports.RangeNode = RangeNode;
 var RelationalNode = (0, _factoriesNumber.createRelationalNode)({
   Node: Node
 });
 exports.RelationalNode = RelationalNode;
-var reviver = (0, _factoriesNumber.createReviver)({
-  classes: classes
-});
-exports.reviver = reviver;
-var BlockNode = (0, _factoriesNumber.createBlockNode)({
-  Node: Node,
-  ResultSet: _pureFunctionsNumberGenerated.ResultSet
-});
-exports.BlockNode = BlockNode;
-var OperatorNode = (0, _factoriesNumber.createOperatorNode)({
-  Node: Node
-});
-exports.OperatorNode = OperatorNode;
 var SymbolNode = (0, _factoriesNumber.createSymbolNode)({
   Node: Node,
   math: math
@@ -94,20 +73,16 @@ var AccessorNode = (0, _factoriesNumber.createAccessorNode)({
   subset: _pureFunctionsNumberGenerated.subset
 });
 exports.AccessorNode = AccessorNode;
-var ConstantNode = (0, _factoriesNumber.createConstantNode)({
-  Node: Node
-});
-exports.ConstantNode = ConstantNode;
-var RangeNode = (0, _factoriesNumber.createRangeNode)({
-  Node: Node
-});
-exports.RangeNode = RangeNode;
 var AssignmentNode = (0, _factoriesNumber.createAssignmentNode)({
   matrix: _pureFunctionsNumberGenerated.matrix,
   Node: Node,
   subset: _pureFunctionsNumberGenerated.subset
 });
 exports.AssignmentNode = AssignmentNode;
+var ConditionalNode = (0, _factoriesNumber.createConditionalNode)({
+  Node: Node
+});
+exports.ConditionalNode = ConditionalNode;
 var FunctionNode = (0, _factoriesNumber.createFunctionNode)({
   Node: Node,
   SymbolNode: SymbolNode,
@@ -120,6 +95,32 @@ var IndexNode = (0, _factoriesNumber.createIndexNode)({
   size: _pureFunctionsNumberGenerated.size
 });
 exports.IndexNode = IndexNode;
+var OperatorNode = (0, _factoriesNumber.createOperatorNode)({
+  Node: Node
+});
+exports.OperatorNode = OperatorNode;
+var ConstantNode = (0, _factoriesNumber.createConstantNode)({
+  Node: Node
+});
+exports.ConstantNode = ConstantNode;
+var FunctionAssignmentNode = (0, _factoriesNumber.createFunctionAssignmentNode)({
+  Node: Node,
+  typed: _pureFunctionsNumberGenerated.typed
+});
+exports.FunctionAssignmentNode = FunctionAssignmentNode;
+var ParenthesisNode = (0, _factoriesNumber.createParenthesisNode)({
+  Node: Node
+});
+exports.ParenthesisNode = ParenthesisNode;
+var BlockNode = (0, _factoriesNumber.createBlockNode)({
+  Node: Node,
+  ResultSet: _pureFunctionsNumberGenerated.ResultSet
+});
+exports.BlockNode = BlockNode;
+var ArrayNode = (0, _factoriesNumber.createArrayNode)({
+  Node: Node
+});
+exports.ArrayNode = ArrayNode;
 var parse = (0, _factoriesNumber.createParse)({
   AccessorNode: AccessorNode,
   ArrayNode: ArrayNode,
@@ -141,6 +142,30 @@ var parse = (0, _factoriesNumber.createParse)({
   typed: _pureFunctionsNumberGenerated.typed
 });
 exports.parse = parse;
+var simplify = (0, _factoriesNumber.createSimplify)({
+  ConstantNode: ConstantNode,
+  FunctionNode: FunctionNode,
+  OperatorNode: OperatorNode,
+  ParenthesisNode: ParenthesisNode,
+  SymbolNode: SymbolNode,
+  add: _pureFunctionsNumberGenerated.add,
+  config: _configReadonly.config,
+  divide: _pureFunctionsNumberGenerated.divide,
+  equal: _pureFunctionsNumberGenerated.equal,
+  isZero: _pureFunctionsNumberGenerated.isZero,
+  mathWithTransform: mathWithTransform,
+  multiply: _pureFunctionsNumberGenerated.multiply,
+  parse: parse,
+  pow: _pureFunctionsNumberGenerated.pow,
+  subtract: _pureFunctionsNumberGenerated.subtract,
+  typed: _pureFunctionsNumberGenerated.typed
+});
+exports.simplify = simplify;
+var compile = (0, _factoriesNumber.createCompile)({
+  parse: parse,
+  typed: _pureFunctionsNumberGenerated.typed
+});
+exports.compile = compile;
 var evaluate = (0, _factoriesNumber.createEvaluate)({
   parse: parse,
   typed: _pureFunctionsNumberGenerated.typed
@@ -150,25 +175,25 @@ var Help = (0, _factoriesNumber.createHelpClass)({
   parse: parse
 });
 exports.Help = Help;
-var simplify = (0, _factoriesNumber.createSimplify)({
+var Parser = (0, _factoriesNumber.createParserClass)({
+  evaluate: evaluate
+});
+exports.Parser = Parser;
+var derivative = (0, _factoriesNumber.createDerivative)({
   ConstantNode: ConstantNode,
   FunctionNode: FunctionNode,
   OperatorNode: OperatorNode,
   ParenthesisNode: ParenthesisNode,
   SymbolNode: SymbolNode,
-  add: _pureFunctionsNumberGenerated.add,
   config: _configReadonly.config,
-  divide: _pureFunctionsNumberGenerated.divide,
   equal: _pureFunctionsNumberGenerated.equal,
   isZero: _pureFunctionsNumberGenerated.isZero,
-  mathWithTransform: mathWithTransform,
-  multiply: _pureFunctionsNumberGenerated.multiply,
+  numeric: _pureFunctionsNumberGenerated.numeric,
   parse: parse,
-  pow: _pureFunctionsNumberGenerated.pow,
-  subtract: _pureFunctionsNumberGenerated.subtract,
+  simplify: simplify,
   typed: _pureFunctionsNumberGenerated.typed
 });
-exports.simplify = simplify;
+exports.derivative = derivative;
 var rationalize = (0, _factoriesNumber.createRationalize)({
   ConstantNode: ConstantNode,
   FunctionNode: FunctionNode,
@@ -189,219 +214,211 @@ var rationalize = (0, _factoriesNumber.createRationalize)({
   typed: _pureFunctionsNumberGenerated.typed
 });
 exports.rationalize = rationalize;
-var compile = (0, _factoriesNumber.createCompile)({
-  parse: parse,
-  typed: _pureFunctionsNumberGenerated.typed
-});
-exports.compile = compile;
 var help = (0, _factoriesNumber.createHelp)({
   Help: Help,
   mathWithTransform: mathWithTransform,
   typed: _pureFunctionsNumberGenerated.typed
 });
 exports.help = help;
-var Parser = (0, _factoriesNumber.createParserClass)({
-  evaluate: evaluate
-});
-exports.Parser = Parser;
-var derivative = (0, _factoriesNumber.createDerivative)({
-  ConstantNode: ConstantNode,
-  FunctionNode: FunctionNode,
-  OperatorNode: OperatorNode,
-  ParenthesisNode: ParenthesisNode,
-  SymbolNode: SymbolNode,
-  config: _configReadonly.config,
-  equal: _pureFunctionsNumberGenerated.equal,
-  isZero: _pureFunctionsNumberGenerated.isZero,
-  numeric: _pureFunctionsNumberGenerated.numeric,
-  parse: parse,
-  simplify: simplify,
-  typed: _pureFunctionsNumberGenerated.typed
-});
-exports.derivative = derivative;
 var parser = (0, _factoriesNumber.createParser)({
   Parser: Parser,
   typed: _pureFunctionsNumberGenerated.typed
 });
 exports.parser = parser;
 (0, _extends2["default"])(math, {
-  typed: _pureFunctionsNumberGenerated.typed,
-  chain: chain,
-  nthRoot: _pureFunctionsNumberGenerated.nthRoot,
   e: _pureFunctionsNumberGenerated.e,
   "false": _pureFunctionsNumberGenerated._false,
+  index: _pureFunctionsNumberGenerated.index,
+  Infinity: _pureFunctionsNumberGenerated._Infinity,
   LN10: _pureFunctionsNumberGenerated.LN10,
   LOG10E: _pureFunctionsNumberGenerated.LOG10E,
+  matrix: _pureFunctionsNumberGenerated.matrix,
   NaN: _pureFunctionsNumberGenerated._NaN,
+  "null": _pureFunctionsNumberGenerated._null,
   phi: _pureFunctionsNumberGenerated.phi,
+  replacer: _pureFunctionsNumberGenerated.replacer,
+  reviver: reviver,
   SQRT1_2: _pureFunctionsNumberGenerated.SQRT1_2,
+  subset: _pureFunctionsNumberGenerated.subset,
   tau: _pureFunctionsNumberGenerated.tau,
+  typed: _pureFunctionsNumberGenerated.typed,
+  unaryPlus: _pureFunctionsNumberGenerated.unaryPlus,
+  'E': _pureFunctionsNumberGenerated.e,
   version: _pureFunctionsNumberGenerated.version,
-  string: _pureFunctionsNumberGenerated.string,
-  filter: _pureFunctionsNumberGenerated.filter,
-  map: _pureFunctionsNumberGenerated.map,
-  combinationsWithRep: _pureFunctionsNumberGenerated.combinationsWithRep,
-  pickRandom: _pureFunctionsNumberGenerated.pickRandom,
-  randomInt: _pureFunctionsNumberGenerated.randomInt,
-  compare: _pureFunctionsNumberGenerated.compare,
-  compareText: _pureFunctionsNumberGenerated.compareText,
-  smaller: _pureFunctionsNumberGenerated.smaller,
-  larger: _pureFunctionsNumberGenerated.larger,
-  erf: _pureFunctionsNumberGenerated.erf,
-  format: _pureFunctionsNumberGenerated.format,
-  clone: _pureFunctionsNumberGenerated.clone,
-  typeOf: _pureFunctionsNumberGenerated.typeOf,
-  reviver: reviver,
-  unaryMinus: _pureFunctionsNumberGenerated.unaryMinus,
-  abs: _pureFunctionsNumberGenerated.abs,
-  cbrt: _pureFunctionsNumberGenerated.cbrt,
-  cube: _pureFunctionsNumberGenerated.cube,
-  expm1: _pureFunctionsNumberGenerated.expm1,
-  floor: _pureFunctionsNumberGenerated.floor,
-  lcm: _pureFunctionsNumberGenerated.lcm,
-  log2: _pureFunctionsNumberGenerated.log2,
-  multiplyScalar: _pureFunctionsNumberGenerated.multiplyScalar,
-  sign: _pureFunctionsNumberGenerated.sign,
-  square: _pureFunctionsNumberGenerated.square,
-  xgcd: _pureFunctionsNumberGenerated.xgcd,
-  pow: _pureFunctionsNumberGenerated.pow,
-  log1p: _pureFunctionsNumberGenerated.log1p,
-  norm: _pureFunctionsNumberGenerated.norm,
-  bitAnd: _pureFunctionsNumberGenerated.bitAnd,
-  bitOr: _pureFunctionsNumberGenerated.bitOr,
-  leftShift: _pureFunctionsNumberGenerated.leftShift,
-  rightLogShift: _pureFunctionsNumberGenerated.rightLogShift,
-  not: _pureFunctionsNumberGenerated.not,
   xor: _pureFunctionsNumberGenerated.xor,
-  matrix: _pureFunctionsNumberGenerated.matrix,
-  combinations: _pureFunctionsNumberGenerated.combinations,
+  abs: _pureFunctionsNumberGenerated.abs,
   acos: _pureFunctionsNumberGenerated.acos,
   acot: _pureFunctionsNumberGenerated.acot,
   acsc: _pureFunctionsNumberGenerated.acsc,
+  add: _pureFunctionsNumberGenerated.add,
+  and: _pureFunctionsNumberGenerated.and,
   asec: _pureFunctionsNumberGenerated.asec,
   asin: _pureFunctionsNumberGenerated.asin,
   atan: _pureFunctionsNumberGenerated.atan,
   atanh: _pureFunctionsNumberGenerated.atanh,
-  cosh: _pureFunctionsNumberGenerated.cosh,
-  coth: _pureFunctionsNumberGenerated.coth,
-  csch: _pureFunctionsNumberGenerated.csch,
-  sech: _pureFunctionsNumberGenerated.sech,
-  sinh: _pureFunctionsNumberGenerated.sinh,
-  tanh: _pureFunctionsNumberGenerated.tanh,
+  bitAnd: _pureFunctionsNumberGenerated.bitAnd,
+  bitOr: _pureFunctionsNumberGenerated.bitOr,
+  "boolean": _pureFunctionsNumberGenerated["boolean"],
+  cbrt: _pureFunctionsNumberGenerated.cbrt,
+  chain: chain,
+  combinations: _pureFunctionsNumberGenerated.combinations,
+  compare: _pureFunctionsNumberGenerated.compare,
+  compareText: _pureFunctionsNumberGenerated.compareText,
+  cos: _pureFunctionsNumberGenerated.cos,
+  cot: _pureFunctionsNumberGenerated.cot,
+  csc: _pureFunctionsNumberGenerated.csc,
+  cube: _pureFunctionsNumberGenerated.cube,
+  divide: _pureFunctionsNumberGenerated.divide,
+  equalScalar: _pureFunctionsNumberGenerated.equalScalar,
+  erf: _pureFunctionsNumberGenerated.erf,
+  exp: _pureFunctionsNumberGenerated.exp,
+  filter: _pureFunctionsNumberGenerated.filter,
+  fix: _pureFunctionsNumberGenerated.fix,
+  forEach: _pureFunctionsNumberGenerated.forEach,
+  format: _pureFunctionsNumberGenerated.format,
+  gamma: _pureFunctionsNumberGenerated.gamma,
   isInteger: _pureFunctionsNumberGenerated.isInteger,
+  isNegative: _pureFunctionsNumberGenerated.isNegative,
   isPositive: _pureFunctionsNumberGenerated.isPositive,
-  isNaN: _pureFunctionsNumberGenerated.isNaN,
-  round: _pureFunctionsNumberGenerated.round,
-  'E': _pureFunctionsNumberGenerated.e,
-  LN2: _pureFunctionsNumberGenerated.LN2,
-  "null": _pureFunctionsNumberGenerated._null,
-  SQRT2: _pureFunctionsNumberGenerated.SQRT2,
+  isZero: _pureFunctionsNumberGenerated.isZero,
+  LOG2E: _pureFunctionsNumberGenerated.LOG2E,
+  largerEq: _pureFunctionsNumberGenerated.largerEq,
+  leftShift: _pureFunctionsNumberGenerated.leftShift,
+  log10: _pureFunctionsNumberGenerated.log10,
+  log2: _pureFunctionsNumberGenerated.log2,
+  map: _pureFunctionsNumberGenerated.map,
+  mean: _pureFunctionsNumberGenerated.mean,
+  mod: _pureFunctionsNumberGenerated.mod,
+  multiply: _pureFunctionsNumberGenerated.multiply,
+  not: _pureFunctionsNumberGenerated.not,
   number: _pureFunctionsNumberGenerated.number,
-  apply: _pureFunctionsNumberGenerated.apply,
-  size: _pureFunctionsNumberGenerated.size,
+  or: _pureFunctionsNumberGenerated.or,
+  pi: _pureFunctionsNumberGenerated.pi,
+  pow: _pureFunctionsNumberGenerated.pow,
   random: _pureFunctionsNumberGenerated.random,
-  compareNatural: _pureFunctionsNumberGenerated.compareNatural,
+  rightArithShift: _pureFunctionsNumberGenerated.rightArithShift,
+  round: _pureFunctionsNumberGenerated.round,
+  sec: _pureFunctionsNumberGenerated.sec,
+  sign: _pureFunctionsNumberGenerated.sign,
+  sin: _pureFunctionsNumberGenerated.sin,
+  size: _pureFunctionsNumberGenerated.size,
   smallerEq: _pureFunctionsNumberGenerated.smallerEq,
-  print: _pureFunctionsNumberGenerated.print,
-  isNumeric: _pureFunctionsNumberGenerated.isNumeric,
-  isPrime: _pureFunctionsNumberGenerated.isPrime,
-  replacer: _pureFunctionsNumberGenerated.replacer,
+  square: _pureFunctionsNumberGenerated.square,
+  string: _pureFunctionsNumberGenerated.string,
+  subtract: _pureFunctionsNumberGenerated.subtract,
+  tanh: _pureFunctionsNumberGenerated.tanh,
+  typeOf: _pureFunctionsNumberGenerated.typeOf,
+  unequal: _pureFunctionsNumberGenerated.unequal,
+  xgcd: _pureFunctionsNumberGenerated.xgcd,
+  acoth: _pureFunctionsNumberGenerated.acoth,
   addScalar: _pureFunctionsNumberGenerated.addScalar,
-  exp: _pureFunctionsNumberGenerated.exp,
-  gcd: _pureFunctionsNumberGenerated.gcd,
-  mod: _pureFunctionsNumberGenerated.mod,
-  sqrt: _pureFunctionsNumberGenerated.sqrt,
-  divideScalar: _pureFunctionsNumberGenerated.divideScalar,
-  add: _pureFunctionsNumberGenerated.add,
+  asech: _pureFunctionsNumberGenerated.asech,
   bitNot: _pureFunctionsNumberGenerated.bitNot,
-  rightArithShift: _pureFunctionsNumberGenerated.rightArithShift,
-  or: _pureFunctionsNumberGenerated.or,
-  subset: _pureFunctionsNumberGenerated.subset,
+  ceil: _pureFunctionsNumberGenerated.ceil,
+  combinationsWithRep: _pureFunctionsNumberGenerated.combinationsWithRep,
+  cosh: _pureFunctionsNumberGenerated.cosh,
+  csch: _pureFunctionsNumberGenerated.csch,
+  divideScalar: _pureFunctionsNumberGenerated.divideScalar,
+  equalText: _pureFunctionsNumberGenerated.equalText,
+  expm1: _pureFunctionsNumberGenerated.expm1,
+  isNumeric: _pureFunctionsNumberGenerated.isNumeric,
+  LN2: _pureFunctionsNumberGenerated.LN2,
+  lcm: _pureFunctionsNumberGenerated.lcm,
+  log1p: _pureFunctionsNumberGenerated.log1p,
+  multiplyScalar: _pureFunctionsNumberGenerated.multiplyScalar,
+  nthRoot: _pureFunctionsNumberGenerated.nthRoot,
+  pickRandom: _pureFunctionsNumberGenerated.pickRandom,
+  randomInt: _pureFunctionsNumberGenerated.randomInt,
+  SQRT2: _pureFunctionsNumberGenerated.SQRT2,
+  sinh: _pureFunctionsNumberGenerated.sinh,
+  sqrt: _pureFunctionsNumberGenerated.sqrt,
+  tan: _pureFunctionsNumberGenerated.tan,
+  unaryMinus: _pureFunctionsNumberGenerated.unaryMinus,
   acosh: _pureFunctionsNumberGenerated.acosh,
-  acsch: _pureFunctionsNumberGenerated.acsch,
+  apply: _pureFunctionsNumberGenerated.apply,
   asinh: _pureFunctionsNumberGenerated.asinh,
-  cos: _pureFunctionsNumberGenerated.cos,
-  csc: _pureFunctionsNumberGenerated.csc,
-  sin: _pureFunctionsNumberGenerated.sin,
-  isZero: _pureFunctionsNumberGenerated.isZero,
-  hypot: _pureFunctionsNumberGenerated.hypot,
-  Infinity: _pureFunctionsNumberGenerated._Infinity,
-  pi: _pureFunctionsNumberGenerated.pi,
-  "true": _pureFunctionsNumberGenerated._true,
-  forEach: _pureFunctionsNumberGenerated.forEach,
-  partitionSelect: _pureFunctionsNumberGenerated.partitionSelect,
-  equalScalar: _pureFunctionsNumberGenerated.equalScalar,
-  equalText: _pureFunctionsNumberGenerated.equalText,
-  unequal: _pureFunctionsNumberGenerated.unequal,
-  hasNumericValue: _pureFunctionsNumberGenerated.hasNumericValue,
-  unaryPlus: _pureFunctionsNumberGenerated.unaryPlus,
-  fix: _pureFunctionsNumberGenerated.fix,
-  multiply: _pureFunctionsNumberGenerated.multiply,
-  log: _pureFunctionsNumberGenerated.log,
   bitXor: _pureFunctionsNumberGenerated.bitXor,
-  index: _pureFunctionsNumberGenerated.index,
-  acoth: _pureFunctionsNumberGenerated.acoth,
-  atan2: _pureFunctionsNumberGenerated.atan2,
-  sec: _pureFunctionsNumberGenerated.sec,
-  isNegative: _pureFunctionsNumberGenerated.isNegative,
   catalan: _pureFunctionsNumberGenerated.catalan,
-  LOG2E: _pureFunctionsNumberGenerated.LOG2E,
-  "boolean": _pureFunctionsNumberGenerated["boolean"],
+  compareNatural: _pureFunctionsNumberGenerated.compareNatural,
   equal: _pureFunctionsNumberGenerated.equal,
-  deepEqual: _pureFunctionsNumberGenerated.deepEqual,
-  quantileSeq: _pureFunctionsNumberGenerated.quantileSeq,
-  numeric: _pureFunctionsNumberGenerated.numeric,
-  log10: _pureFunctionsNumberGenerated.log10,
-  divide: _pureFunctionsNumberGenerated.divide,
-  gamma: _pureFunctionsNumberGenerated.gamma,
-  cot: _pureFunctionsNumberGenerated.cot,
-  composition: _pureFunctionsNumberGenerated.composition,
   factorial: _pureFunctionsNumberGenerated.factorial,
-  permutations: _pureFunctionsNumberGenerated.permutations,
+  hasNumericValue: _pureFunctionsNumberGenerated.hasNumericValue,
+  isNaN: _pureFunctionsNumberGenerated.isNaN,
+  larger: _pureFunctionsNumberGenerated.larger,
   mode: _pureFunctionsNumberGenerated.mode,
-  max: _pureFunctionsNumberGenerated.max,
-  sum: _pureFunctionsNumberGenerated.sum,
+  norm: _pureFunctionsNumberGenerated.norm,
+  partitionSelect: _pureFunctionsNumberGenerated.partitionSelect,
+  print: _pureFunctionsNumberGenerated.print,
+  quantileSeq: _pureFunctionsNumberGenerated.quantileSeq,
+  rightLogShift: _pureFunctionsNumberGenerated.rightLogShift,
+  smaller: _pureFunctionsNumberGenerated.smaller,
+  stirlingS2: _pureFunctionsNumberGenerated.stirlingS2,
+  "true": _pureFunctionsNumberGenerated._true,
+  variance: _pureFunctionsNumberGenerated.variance,
+  acsch: _pureFunctionsNumberGenerated.acsch,
+  atan2: _pureFunctionsNumberGenerated.atan2,
+  composition: _pureFunctionsNumberGenerated.composition,
+  deepEqual: _pureFunctionsNumberGenerated.deepEqual,
+  floor: _pureFunctionsNumberGenerated.floor,
+  hypot: _pureFunctionsNumberGenerated.hypot,
+  log: _pureFunctionsNumberGenerated.log,
   median: _pureFunctionsNumberGenerated.median,
-  ceil: _pureFunctionsNumberGenerated.ceil,
-  and: _pureFunctionsNumberGenerated.and,
-  tan: _pureFunctionsNumberGenerated.tan,
-  'PI': _pureFunctionsNumberGenerated.pi,
-  parse: parse,
-  evaluate: evaluate,
   multinomial: _pureFunctionsNumberGenerated.multinomial,
+  permutations: _pureFunctionsNumberGenerated.permutations,
+  range: _pureFunctionsNumberGenerated.range,
+  sech: _pureFunctionsNumberGenerated.sech,
+  std: _pureFunctionsNumberGenerated.std,
+  'PI': _pureFunctionsNumberGenerated.pi,
+  clone: _pureFunctionsNumberGenerated.clone,
+  coth: _pureFunctionsNumberGenerated.coth,
+  gcd: _pureFunctionsNumberGenerated.gcd,
+  isPrime: _pureFunctionsNumberGenerated.isPrime,
+  numeric: _pureFunctionsNumberGenerated.numeric,
   prod: _pureFunctionsNumberGenerated.prod,
-  mean: _pureFunctionsNumberGenerated.mean,
-  subtract: _pureFunctionsNumberGenerated.subtract,
+  bellNumbers: _pureFunctionsNumberGenerated.bellNumbers,
+  mad: _pureFunctionsNumberGenerated.mad,
+  sum: _pureFunctionsNumberGenerated.sum,
+  max: _pureFunctionsNumberGenerated.max,
+  parse: parse,
   simplify: simplify,
-  rationalize: rationalize,
   compile: compile,
-  largerEq: _pureFunctionsNumberGenerated.largerEq,
-  mad: _pureFunctionsNumberGenerated.mad,
-  help: help,
-  stirlingS2: _pureFunctionsNumberGenerated.stirlingS2,
-  min: _pureFunctionsNumberGenerated.min,
-  asech: _pureFunctionsNumberGenerated.asech,
+  evaluate: evaluate,
   derivative: derivative,
+  min: _pureFunctionsNumberGenerated.min,
+  rationalize: rationalize,
+  help: help,
   parser: parser,
-  variance: _pureFunctionsNumberGenerated.variance,
-  bellNumbers: _pureFunctionsNumberGenerated.bellNumbers,
-  std: _pureFunctionsNumberGenerated.std,
-  range: _pureFunctionsNumberGenerated.range,
   config: _configReadonly.config
 });
 (0, _extends2["default"])(mathWithTransform, math, {
+  apply: (0, _factoriesNumber.createApplyTransform)({
+    isInteger: _pureFunctionsNumberGenerated.isInteger,
+    typed: _pureFunctionsNumberGenerated.typed
+  }),
   filter: (0, _factoriesNumber.createFilterTransform)({
     typed: _pureFunctionsNumberGenerated.typed
   }),
+  forEach: (0, _factoriesNumber.createForEachTransform)({
+    typed: _pureFunctionsNumberGenerated.typed
+  }),
   map: (0, _factoriesNumber.createMapTransform)({
     typed: _pureFunctionsNumberGenerated.typed
   }),
-  forEach: (0, _factoriesNumber.createForEachTransform)({
+  mean: (0, _factoriesNumber.createMeanTransform)({
+    add: _pureFunctionsNumberGenerated.add,
+    divide: _pureFunctionsNumberGenerated.divide,
     typed: _pureFunctionsNumberGenerated.typed
   }),
   subset: (0, _factoriesNumber.createSubsetTransform)({}),
-  apply: (0, _factoriesNumber.createApplyTransform)({
-    isInteger: _pureFunctionsNumberGenerated.isInteger,
+  std: (0, _factoriesNumber.createStdTransform)({
+    sqrt: _pureFunctionsNumberGenerated.sqrt,
+    typed: _pureFunctionsNumberGenerated.typed,
+    variance: _pureFunctionsNumberGenerated.variance
+  }),
+  sum: (0, _factoriesNumber.createSumTransform)({
+    add: _pureFunctionsNumberGenerated.add,
+    config: _configReadonly.config,
+    numeric: _pureFunctionsNumberGenerated.numeric,
     typed: _pureFunctionsNumberGenerated.typed
   }),
   max: (0, _factoriesNumber.createMaxTransform)({
@@ -416,17 +433,6 @@ exports.parser = parser;
     smaller: _pureFunctionsNumberGenerated.smaller,
     typed: _pureFunctionsNumberGenerated.typed
   }),
-  sum: (0, _factoriesNumber.createSumTransform)({
-    add: _pureFunctionsNumberGenerated.add,
-    config: _configReadonly.config,
-    numeric: _pureFunctionsNumberGenerated.numeric,
-    typed: _pureFunctionsNumberGenerated.typed
-  }),
-  mean: (0, _factoriesNumber.createMeanTransform)({
-    add: _pureFunctionsNumberGenerated.add,
-    divide: _pureFunctionsNumberGenerated.divide,
-    typed: _pureFunctionsNumberGenerated.typed
-  }),
   range: (0, _factoriesNumber.createRangeTransform)({
     matrix: _pureFunctionsNumberGenerated.matrix,
     config: _configReadonly.config,
@@ -444,33 +450,28 @@ exports.parser = parser;
     multiply: _pureFunctionsNumberGenerated.multiply,
     subtract: _pureFunctionsNumberGenerated.subtract,
     typed: _pureFunctionsNumberGenerated.typed
-  }),
-  std: (0, _factoriesNumber.createStdTransform)({
-    sqrt: _pureFunctionsNumberGenerated.sqrt,
-    typed: _pureFunctionsNumberGenerated.typed,
-    variance: _pureFunctionsNumberGenerated.variance
   })
 });
 (0, _extends2["default"])(classes, {
-  Range: _pureFunctionsNumberGenerated.Range,
   Chain: Chain,
+  Range: _pureFunctionsNumberGenerated.Range,
   Node: Node,
-  ArrayNode: ArrayNode,
-  ConditionalNode: ConditionalNode,
-  FunctionAssignmentNode: FunctionAssignmentNode,
   ObjectNode: ObjectNode,
-  ParenthesisNode: ParenthesisNode,
+  RangeNode: RangeNode,
   RelationalNode: RelationalNode,
-  ResultSet: _pureFunctionsNumberGenerated.ResultSet,
-  BlockNode: BlockNode,
-  OperatorNode: OperatorNode,
   SymbolNode: SymbolNode,
   AccessorNode: AccessorNode,
-  ConstantNode: ConstantNode,
-  RangeNode: RangeNode,
   AssignmentNode: AssignmentNode,
+  ConditionalNode: ConditionalNode,
   FunctionNode: FunctionNode,
   IndexNode: IndexNode,
+  OperatorNode: OperatorNode,
+  ResultSet: _pureFunctionsNumberGenerated.ResultSet,
+  ConstantNode: ConstantNode,
+  FunctionAssignmentNode: FunctionAssignmentNode,
+  ParenthesisNode: ParenthesisNode,
+  BlockNode: BlockNode,
+  ArrayNode: ArrayNode,
   Help: Help,
   Parser: Parser
 });

package/lib/cjs/entry/mainAny.js

@@ -11,28 +11,28 @@ var _exportNames = {
   create: true,
   factory: true
 };
-Object.defineProperty(exports, "config", {
+Object.defineProperty(exports, "ArgumentsError", {
   enumerable: true,
   get: function get() {
-    return _configReadonly.config;
+    return _ArgumentsError.ArgumentsError;
   }
 });
-Object.defineProperty(exports, "IndexError", {
+Object.defineProperty(exports, "DimensionError", {
   enumerable: true,
   get: function get() {
-    return _IndexError.IndexError;
+    return _DimensionError.DimensionError;
   }
 });
-Object.defineProperty(exports, "DimensionError", {
+Object.defineProperty(exports, "IndexError", {
   enumerable: true,
   get: function get() {
-    return _DimensionError.DimensionError;
+    return _IndexError.IndexError;
   }
 });
-Object.defineProperty(exports, "ArgumentsError", {
+Object.defineProperty(exports, "config", {
   enumerable: true,
   get: function get() {
-    return _ArgumentsError.ArgumentsError;
+    return _configReadonly.config;
   }
 });
 Object.defineProperty(exports, "create", {