"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
Object.defineProperty(exports, "docs", {
  enumerable: true,
  get: function get() {
    return _embeddedDocs.embeddedDocs;
  }
});
exports.reviver = exports.rationalize = exports.derivative = exports.simplify = exports.chain = exports.help = exports.Chain = exports.Help = exports.parser = exports.Parser = exports.evaluate = exports.compile = exports.parse = exports.FunctionNode = exports.SymbolNode = exports.RelationalNode = exports.RangeNode = exports.ParenthesisNode = exports.OperatorNode = exports.ObjectNode = exports.IndexNode = exports.FunctionAssignmentNode = exports.ConstantNode = exports.ConditionalNode = exports.BlockNode = exports.AssignmentNode = exports.ArrayNode = exports.AccessorNode = exports.Node = void 0;

var _apply = require("../expression/transform/apply.transform");

var _column = require("../expression/transform/column.transform");

var _concat = require("../expression/transform/concat.transform");

var _filter = require("../expression/transform/filter.transform");

var _forEach = require("../expression/transform/forEach.transform");

var _index = require("../expression/transform/index.transform");

var _map = require("../expression/transform/map.transform");

var _max = require("../expression/transform/max.transform");

var _mean = require("../expression/transform/mean.transform");

var _min = require("../expression/transform/min.transform");

var _range = require("../expression/transform/range.transform");

var _row = require("../expression/transform/row.transform");

var _subset = require("../expression/transform/subset.transform");

var _sum = require("../expression/transform/sum.transform");

var _std = require("../expression/transform/std.transform");

var _variance = require("../expression/transform/variance.transform");

var _Node = require("../expression/node/Node");

var _AccessorNode = require("../expression/node/AccessorNode");

var _ArrayNode = require("../expression/node/ArrayNode");

var _AssignmentNode = require("../expression/node/AssignmentNode");

var _BlockNode = require("../expression/node/BlockNode");

var _ConditionalNode = require("../expression/node/ConditionalNode");

var _ConstantNode = require("../expression/node/ConstantNode");

var _FunctionAssignmentNode = require("../expression/node/FunctionAssignmentNode");

var _IndexNode = require("../expression/node/IndexNode");

var _ObjectNode = require("../expression/node/ObjectNode");

var _OperatorNode = require("../expression/node/OperatorNode");

var _ParenthesisNode = require("../expression/node/ParenthesisNode");

var _RangeNode = require("../expression/node/RangeNode");

var _RelationalNode = require("../expression/node/RelationalNode");

var _SymbolNode = require("../expression/node/SymbolNode");

var _FunctionNode = require("../expression/node/FunctionNode");

var _parse = require("../expression/parse");

var _compile = require("../expression/function/compile");

var _evaluate = require("../expression/function/evaluate");

var _Parser = require("../expression/Parser");

var _parser = require("../expression/function/parser");

var _Help = require("../expression/Help");

var _Chain = require("../type/chain/Chain");

var _help = require("../expression/function/help");

var _chain = require("../type/chain/function/chain");

var _simplify = require("../function/algebra/simplify");

var _derivative = require("../function/algebra/derivative");

var _rationalize = require("../function/algebra/rationalize");

var _reviver = require("../json/reviver");

var _functionsAny = require("./functionsAny");

var _embeddedDocs = require("../expression/embeddedDocs/embeddedDocs");

function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

var math = {}; // NOT pure!

var mathWithTransform = {}; // NOT pure!
// expression (4)

var Node =
/* #__PURE__ */
(0, _Node.createNode)({
  mathWithTransform: mathWithTransform
});
exports.Node = Node;
var AccessorNode =
/* #__PURE__ */
(0, _AccessorNode.createAccessorNode)({
  subset: _functionsAny.subset,
  Node: Node
});
exports.AccessorNode = AccessorNode;
var ArrayNode =
/* #__PURE__ */
(0, _ArrayNode.createArrayNode)({
  Node: Node
});
exports.ArrayNode = ArrayNode;
var AssignmentNode =
/* #__PURE__ */
(0, _AssignmentNode.createAssignmentNode)({
  subset: _functionsAny.subset,
  matrix: _functionsAny.matrix,
  Node: Node
});
exports.AssignmentNode = AssignmentNode;
var BlockNode =
/* #__PURE__ */
(0, _BlockNode.createBlockNode)({
  ResultSet: _functionsAny.ResultSet,
  Node: Node
});
exports.BlockNode = BlockNode;
var ConditionalNode =
/* #__PURE__ */
(0, _ConditionalNode.createConditionalNode)({
  Node: Node
});
exports.ConditionalNode = ConditionalNode;
var ConstantNode =
/* #__PURE__ */
(0, _ConstantNode.createConstantNode)({
  Node: Node
});
exports.ConstantNode = ConstantNode;
var FunctionAssignmentNode =
/* #__PURE__ */
(0, _FunctionAssignmentNode.createFunctionAssignmentNode)({
  typed: _functionsAny.typed,
  Node: Node
});
exports.FunctionAssignmentNode = FunctionAssignmentNode;
var IndexNode =
/* #__PURE__ */
(0, _IndexNode.createIndexNode)({
  Range: _functionsAny.Range,
  Node: Node
});
exports.IndexNode = IndexNode;
var ObjectNode =
/* #__PURE__ */
(0, _ObjectNode.createObjectNode)({
  Node: Node
});
exports.ObjectNode = ObjectNode;
var OperatorNode =
/* #__PURE__ */
(0, _OperatorNode.createOperatorNode)({
  Node: Node
});
exports.OperatorNode = OperatorNode;
var ParenthesisNode =
/* #__PURE__ */
(0, _ParenthesisNode.createParenthesisNode)({
  Node: Node
});
exports.ParenthesisNode = ParenthesisNode;
var RangeNode =
/* #__PURE__ */
(0, _RangeNode.createRangeNode)({
  Node: Node
});
exports.RangeNode = RangeNode;
var RelationalNode =
/* #__PURE__ */
(0, _RelationalNode.createRelationalNode)({
  Node: Node
});
exports.RelationalNode = RelationalNode;
var SymbolNode =
/* #__PURE__ */
(0, _SymbolNode.createSymbolNode)({
  math: math,
  Unit: _functionsAny.Unit,
  Node: Node
});
exports.SymbolNode = SymbolNode;
var FunctionNode =
/* #__PURE__ */
(0, _FunctionNode.createFunctionNode)({
  math: math,
  Node: Node,
  SymbolNode: SymbolNode
});
exports.FunctionNode = FunctionNode;
var parse =
/* #__PURE__ */
(0, _parse.createParse)({
  typed: _functionsAny.typed,
  config: _functionsAny.config,
  numeric: _functionsAny.numeric,
  AccessorNode: AccessorNode,
  ArrayNode: ArrayNode,
  AssignmentNode: AssignmentNode,
  BlockNode: BlockNode,
  ConditionalNode: ConditionalNode,
  ConstantNode: ConstantNode,
  FunctionAssignmentNode: FunctionAssignmentNode,
  FunctionNode: FunctionNode,
  IndexNode: IndexNode,
  ObjectNode: ObjectNode,
  OperatorNode: OperatorNode,
  ParenthesisNode: ParenthesisNode,
  RangeNode: RangeNode,
  RelationalNode: RelationalNode,
  SymbolNode: SymbolNode
});
exports.parse = parse;
var compile =
/* #__PURE__ */
(0, _compile.createCompile)({
  typed: _functionsAny.typed,
  parse: parse
});
exports.compile = compile;
var evaluate =
/* #__PURE__ */
(0, _evaluate.createEvaluate)({
  typed: _functionsAny.typed,
  parse: parse
});
exports.evaluate = evaluate;
var Parser =
/* #__PURE__ */
(0, _Parser.createParserClass)({
  parse: parse
}); // create (4)

exports.Parser = Parser;
var parser =
/* #__PURE__ */
(0, _parser.createParser)({
  math: math,
  typed: _functionsAny.typed,
  Parser: Parser
}); // class (4)

exports.parser = parser;
var Help =
/* #__PURE__ */
(0, _Help.createHelpClass)({
  parse: parse
});
exports.Help = Help;
var Chain =
/* #__PURE__ */
(0, _Chain.createChainClass)({
  math: math
}); // type (4)

exports.Chain = Chain;
var help =
/* #__PURE__ */
(0, _help.createHelp)({
  math: math,
  typed: _functionsAny.typed,
  Help: Help
});
exports.help = help;
var chain =
/* #__PURE__ */
(0, _chain.createChain)({
  typed: _functionsAny.typed,
  Chain: Chain
}); // algebra (4)

exports.chain = chain;
var simplify =
/* #__PURE__ */
(0, _simplify.createSimplify)({
  config: _functionsAny.config,
  typed: _functionsAny.typed,
  parse: parse,
  add: _functionsAny.add,
  subtract: _functionsAny.subtract,
  multiply: _functionsAny.multiply,
  divide: _functionsAny.divide,
  pow: _functionsAny.pow,
  isZero: _functionsAny.isZero,
  equal: _functionsAny.equal,
  fraction: _functionsAny.fraction,
  bignumber: _functionsAny.bignumber,
  math: math,
  ConstantNode: ConstantNode,
  FunctionNode: FunctionNode,
  OperatorNode: OperatorNode,
  ParenthesisNode: ParenthesisNode,
  SymbolNode: SymbolNode
});
exports.simplify = simplify;
var derivative =
/* #__PURE__ */
(0, _derivative.createDerivative)({
  config: _functionsAny.config,
  typed: _functionsAny.typed,
  parse: parse,
  simplify: simplify,
  equal: _functionsAny.equal,
  isZero: _functionsAny.isZero,
  numeric: _functionsAny.numeric,
  ConstantNode: ConstantNode,
  FunctionNode: FunctionNode,
  OperatorNode: OperatorNode,
  ParenthesisNode: ParenthesisNode,
  SymbolNode: SymbolNode
});
exports.derivative = derivative;
var rationalize =
/* #__PURE__ */
(0, _rationalize.createRationalize)({
  config: _functionsAny.config,
  typed: _functionsAny.typed,
  simplify: simplify,
  parse: parse,
  add: _functionsAny.add,
  subtract: _functionsAny.subtract,
  multiply: _functionsAny.multiply,
  divide: _functionsAny.divide,
  pow: _functionsAny.pow,
  isZero: _functionsAny.isZero,
  equal: _functionsAny.equal,
  fraction: _functionsAny.fraction,
  bignumber: _functionsAny.bignumber,
  math: math,
  ConstantNode: ConstantNode,
  FunctionNode: FunctionNode,
  OperatorNode: OperatorNode,
  ParenthesisNode: ParenthesisNode,
  SymbolNode: SymbolNode
}); // ----------------------------------------------------------------------------
// json

exports.rationalize = rationalize;
var reviver =
/* #__PURE__ */
(0, _reviver.createReviver)({
  classes: {
    BigNumber: _functionsAny.BigNumber,
    Chain: Chain,
    Complex: _functionsAny.Complex,
    Fraction: _functionsAny.Fraction,
    Matrix: _functionsAny.Matrix,
    DenseMatrix: _functionsAny.DenseMatrix,
    SparseMatrix: _functionsAny.SparseMatrix,
    Spa: _functionsAny.Spa,
    FibonacciHeap: _functionsAny.FibonacciHeap,
    ImmutableDenseMatrix: _functionsAny.ImmutableDenseMatrix,
    Index: _functionsAny.Index,
    Range: _functionsAny.Range,
    ResultSet: _functionsAny.ResultSet,
    Unit: _functionsAny.Unit,
    Help: Help
  },
  AccessorNode: AccessorNode,
  ArrayNode: ArrayNode,
  AssignmentNode: AssignmentNode,
  BlockNode: BlockNode,
  ConditionalNode: ConditionalNode,
  ConstantNode: ConstantNode,
  FunctionAssignmentNode: FunctionAssignmentNode,
  FunctionNode: FunctionNode,
  IndexNode: IndexNode,
  ObjectNode: ObjectNode,
  OperatorNode: OperatorNode,
  ParenthesisNode: ParenthesisNode,
  RangeNode: RangeNode,
  RelationalNode: RelationalNode,
  SymbolNode: SymbolNode
});
exports.reviver = reviver;

_extends(math, {
  E: _functionsAny.e,
  'Infinity': _functionsAny._Infinity,
  LN10: _functionsAny.LN10,
  LN2: _functionsAny.LN2,
  LOG10E: _functionsAny.LOG10E,
  LOG2E: _functionsAny.LOG2E,
  'NaN': _functionsAny._NaN,
  PI: _functionsAny.pi,
  SQRT1_2: _functionsAny.SQRT1_2,
  SQRT2: _functionsAny.SQRT2,
  abs: _functionsAny.abs,
  acos: _functionsAny.acos,
  acosh: _functionsAny.acosh,
  acot: _functionsAny.acot,
  acoth: _functionsAny.acoth,
  acsc: _functionsAny.acsc,
  acsch: _functionsAny.acsch,
  add: _functionsAny.add,
  addScalar: _functionsAny.addScalar,
  and: _functionsAny.and,
  arg: _functionsAny.arg,
  asec: _functionsAny.asec,
  asech: _functionsAny.asech,
  asin: _functionsAny.asin,
  asinh: _functionsAny.asinh,
  atan: _functionsAny.atan,
  atan2: _functionsAny.atan2,
  atanh: _functionsAny.atanh,
  atomicMass: _functionsAny.atomicMass,
  avogadro: _functionsAny.avogadro,
  bellNumbers: _functionsAny.bellNumbers,
  bignumber: _functionsAny.bignumber,
  bitAnd: _functionsAny.bitAnd,
  bitNot: _functionsAny.bitNot,
  bitOr: _functionsAny.bitOr,
  bitXor: _functionsAny.bitXor,
  bohrMagneton: _functionsAny.bohrMagneton,
  bohrRadius: _functionsAny.bohrRadius,
  boltzmann: _functionsAny.boltzmann,
  "boolean": _functionsAny["boolean"],
  catalan: _functionsAny.catalan,
  cbrt: _functionsAny.cbrt,
  ceil: _functionsAny.ceil,
  chain: chain,
  classicalElectronRadius: _functionsAny.classicalElectronRadius,
  clone: _functionsAny.clone,
  combinations: _functionsAny.combinations,
  compare: _functionsAny.compare,
  compareNatural: _functionsAny.compareNatural,
  compareText: _functionsAny.compareText,
  compile: compile,
  complex: _functionsAny.complex,
  composition: _functionsAny.composition,
  concat: _functionsAny.concat,
  conductanceQuantum: _functionsAny.conductanceQuantum,
  config: _functionsAny.config,
  conj: _functionsAny.conj,
  cos: _functionsAny.cos,
  cosh: _functionsAny.cosh,
  cot: _functionsAny.cot,
  coth: _functionsAny.coth,
  coulomb: _functionsAny.coulomb,
  createUnit: _functionsAny.createUnit,
  cross: _functionsAny.cross,
  csc: _functionsAny.csc,
  csch: _functionsAny.csch,
  ctranspose: _functionsAny.ctranspose,
  cube: _functionsAny.cube,
  deepEqual: _functionsAny.deepEqual,
  derivative: derivative,
  det: _functionsAny.det,
  deuteronMass: _functionsAny.deuteronMass,
  diag: _functionsAny.diag,
  distance: _functionsAny.distance,
  divide: _functionsAny.divide,
  divideScalar: _functionsAny.divideScalar,
  dot: _functionsAny.dot,
  dotDivide: _functionsAny.dotDivide,
  dotMultiply: _functionsAny.dotMultiply,
  dotPow: _functionsAny.dotPow,
  e: _functionsAny.e,
  efimovFactor: _functionsAny.efimovFactor,
  electricConstant: _functionsAny.electricConstant,
  electronMass: _functionsAny.electronMass,
  elementaryCharge: _functionsAny.elementaryCharge,
  equal: _functionsAny.equal,
  equalScalar: _functionsAny.equalScalar,
  equalText: _functionsAny.equalText,
  erf: _functionsAny.erf,
  'eval': evaluate,
  evaluate: evaluate,
  exp: _functionsAny.exp,
  expm: _functionsAny.expm,
  expm1: _functionsAny.expm1,
  eye: _functionsAny.eye,
  factorial: _functionsAny.factorial,
  'false': _functionsAny._false,
  faraday: _functionsAny.faraday,
  fermiCoupling: _functionsAny.fermiCoupling,
  filter: _functionsAny.filter,
  fineStructure: _functionsAny.fineStructure,
  firstRadiation: _functionsAny.firstRadiation,
  fix: _functionsAny.fix,
  flatten: _functionsAny.flatten,
  floor: _functionsAny.floor,
  forEach: _functionsAny.forEach,
  format: _functionsAny.format,
  fraction: _functionsAny.fraction,
  gamma: _functionsAny.gamma,
  gasConstant: _functionsAny.gasConstant,
  gcd: _functionsAny.gcd,
  getMatrixDataType: _functionsAny.getMatrixDataType,
  gravitationConstant: _functionsAny.gravitationConstant,
  gravity: _functionsAny.gravity,
  hartreeEnergy: _functionsAny.hartreeEnergy,
  hasNumericValue: _functionsAny.hasNumericValue,
  help: help,
  hypot: _functionsAny.hypot,
  i: _functionsAny.i,
  identity: _functionsAny.identity,
  im: _functionsAny.im,
  index: _functionsAny.index,
  intersect: _functionsAny.intersect,
  inv: _functionsAny.inv,
  inverseConductanceQuantum: _functionsAny.inverseConductanceQuantum,
  isInteger: _functionsAny.isInteger,
  isNaN: _functionsAny.isNaN,
  isNegative: _functionsAny.isNegative,
  isNumeric: _functionsAny.isNumeric,
  isPositive: _functionsAny.isPositive,
  isPrime: _functionsAny.isPrime,
  isZero: _functionsAny.isZero,
  kldivergence: _functionsAny.kldivergence,
  klitzing: _functionsAny.klitzing,
  kron: _functionsAny.kron,
  larger: _functionsAny.larger,
  largerEq: _functionsAny.largerEq,
  lcm: _functionsAny.lcm,
  leftShift: _functionsAny.leftShift,
  log: _functionsAny.log,
  log10: _functionsAny.log10,
  log1p: _functionsAny.log1p,
  log2: _functionsAny.log2,
  loschmidt: _functionsAny.loschmidt,
  lsolve: _functionsAny.lsolve,
  lup: _functionsAny.lup,
  lusolve: _functionsAny.lusolve,
  mad: _functionsAny.mad,
  magneticConstant: _functionsAny.magneticConstant,
  magneticFluxQuantum: _functionsAny.magneticFluxQuantum,
  map: _functionsAny.map,
  matrix: _functionsAny.matrix,
  max: _functionsAny.max,
  mean: _functionsAny.mean,
  median: _functionsAny.median,
  min: _functionsAny.min,
  mod: _functionsAny.mod,
  mode: _functionsAny.mode,
  molarMass: _functionsAny.molarMass,
  molarMassC12: _functionsAny.molarMassC12,
  molarPlanckConstant: _functionsAny.molarPlanckConstant,
  molarVolume: _functionsAny.molarVolume,
  multinomial: _functionsAny.multinomial,
  multiply: _functionsAny.multiply,
  multiplyScalar: _functionsAny.multiplyScalar,
  neutronMass: _functionsAny.neutronMass,
  norm: _functionsAny.norm,
  not: _functionsAny.not,
  nthRoot: _functionsAny.nthRoot,
  nthRoots: _functionsAny.nthRoots,
  nuclearMagneton: _functionsAny.nuclearMagneton,
  'null': _functionsAny._null,
  number: _functionsAny.number,
  numeric: _functionsAny.numeric,
  ones: _functionsAny.ones,
  or: _functionsAny.or,
  parse: parse,
  parser: parser,
  partitionSelect: _functionsAny.partitionSelect,
  permutations: _functionsAny.permutations,
  phi: _functionsAny.phi,
  pi: _functionsAny.pi,
  pickRandom: _functionsAny.pickRandom,
  planckCharge: _functionsAny.planckCharge,
  planckConstant: _functionsAny.planckConstant,
  planckLength: _functionsAny.planckLength,
  planckMass: _functionsAny.planckMass,
  planckTemperature: _functionsAny.planckTemperature,
  planckTime: _functionsAny.planckTime,
  pow: _functionsAny.pow,
  print: _functionsAny.print,
  prod: _functionsAny.prod,
  protonMass: _functionsAny.protonMass,
  qr: _functionsAny.qr,
  quantileSeq: _functionsAny.quantileSeq,
  quantumOfCirculation: _functionsAny.quantumOfCirculation,
  random: _functionsAny.random,
  randomInt: _functionsAny.randomInt,
  range: _functionsAny.range,
  rationalize: rationalize,
  re: _functionsAny.re,
  reducedPlanckConstant: _functionsAny.reducedPlanckConstant,
  reshape: _functionsAny.reshape,
  resize: _functionsAny.resize,
  reviver: reviver,
  rightArithShift: _functionsAny.rightArithShift,
  rightLogShift: _functionsAny.rightLogShift,
  round: _functionsAny.round,
  rydberg: _functionsAny.rydberg,
  sackurTetrode: _functionsAny.sackurTetrode,
  sec: _functionsAny.sec,
  sech: _functionsAny.sech,
  secondRadiation: _functionsAny.secondRadiation,
  setCartesian: _functionsAny.setCartesian,
  setDifference: _functionsAny.setDifference,
  setDistinct: _functionsAny.setDistinct,
  setIntersect: _functionsAny.setIntersect,
  setIsSubset: _functionsAny.setIsSubset,
  setMultiplicity: _functionsAny.setMultiplicity,
  setPowerset: _functionsAny.setPowerset,
  setSize: _functionsAny.setSize,
  setSymDifference: _functionsAny.setSymDifference,
  setUnion: _functionsAny.setUnion,
  sign: _functionsAny.sign,
  simplify: simplify,
  sin: _functionsAny.sin,
  sinh: _functionsAny.sinh,
  size: _functionsAny.size,
  slu: _functionsAny.slu,
  smaller: _functionsAny.smaller,
  smallerEq: _functionsAny.smallerEq,
  sort: _functionsAny.sort,
  sparse: _functionsAny.sparse,
  speedOfLight: _functionsAny.speedOfLight,
  splitUnit: _functionsAny.splitUnit,
  sqrt: _functionsAny.sqrt,
  sqrtm: _functionsAny.sqrtm,
  square: _functionsAny.square,
  squeeze: _functionsAny.squeeze,
  std: _functionsAny.std,
  stefanBoltzmann: _functionsAny.stefanBoltzmann,
  stirlingS2: _functionsAny.stirlingS2,
  string: _functionsAny.string,
  subset: _functionsAny.subset,
  subtract: _functionsAny.subtract,
  sum: _functionsAny.sum,
  tan: _functionsAny.tan,
  tanh: _functionsAny.tanh,
  tau: _functionsAny.tau,
  thomsonCrossSection: _functionsAny.thomsonCrossSection,
  to: _functionsAny.to,
  trace: _functionsAny.trace,
  transpose: _functionsAny.transpose,
  'true': _functionsAny._true,
  typeOf: _functionsAny.typeOf,
  'typeof': _functionsAny.typeOf,
  typed: _functionsAny.typed,
  unaryMinus: _functionsAny.unaryMinus,
  unaryPlus: _functionsAny.unaryPlus,
  unequal: _functionsAny.unequal,
  unit: _functionsAny.unit,
  usolve: _functionsAny.usolve,
  vacuumImpedance: _functionsAny.vacuumImpedance,
  variance: _functionsAny.variance,
  'var': _functionsAny.variance,
  version: _functionsAny.version,
  weakMixingAngle: _functionsAny.weakMixingAngle,
  wienDisplacement: _functionsAny.wienDisplacement,
  xgcd: _functionsAny.xgcd,
  xor: _functionsAny.xor,
  zeros: _functionsAny.zeros
});

_extends(mathWithTransform, math, {
  apply:
  /* #__PURE__ */
  (0, _apply.createApplyTransform)({
    typed: _functionsAny.typed,
    isInteger: _functionsAny.isInteger
  }),
  column:
  /* #__PURE__ */
  (0, _column.createColumnTransform)({
    typed: _functionsAny.typed,
    Index: _functionsAny.Index,
    matrix: _functionsAny.matrix,
    range: _functionsAny.range
  }),
  concat:
  /* #__PURE__ */
  (0, _concat.createConcatTransform)({
    typed: _functionsAny.typed,
    matrix: _functionsAny.matrix,
    isInteger: _functionsAny.isInteger
  }),
  filter:
  /* #__PURE__ */
  (0, _filter.createFilterTransform)({
    typed: _functionsAny.typed
  }),
  forEach:
  /* #__PURE__ */
  (0, _forEach.createForEachTransform)({
    typed: _functionsAny.typed
  }),
  index:
  /* #__PURE__ */
  (0, _index.createIndexTransform)({
    Index: _functionsAny.Index
  }),
  map:
  /* #__PURE__ */
  (0, _map.createMapTransform)({
    typed: _functionsAny.typed
  }),
  max:
  /* #__PURE__ */
  (0, _max.createMaxTransform)({
    typed: _functionsAny.typed,
    larger: _functionsAny.larger
  }),
  mean:
  /* #__PURE__ */
  (0, _mean.createMeanTransform)({
    typed: _functionsAny.typed,
    add: _functionsAny.add,
    divide: _functionsAny.divide
  }),
  min:
  /* #__PURE__ */
  (0, _min.createMinTransform)({
    typed: _functionsAny.typed,
    smaller: _functionsAny.smaller
  }),
  range:
  /* #__PURE__ */
  (0, _range.createRangeTransform)({
    typed: _functionsAny.typed,
    config: _functionsAny.config,
    matrix: _functionsAny.matrix,
    bignumber: _functionsAny.bignumber,
    smaller: _functionsAny.smaller,
    smallerEq: _functionsAny.smallerEq,
    larger: _functionsAny.larger,
    largerEq: _functionsAny.largerEq
  }),
  row:
  /* #__PURE__ */
  (0, _row.createRowTransform)({
    typed: _functionsAny.typed,
    Index: _functionsAny.Index,
    matrix: _functionsAny.matrix,
    range: _functionsAny.range
  }),
  subset:
  /* #__PURE__ */
  (0, _subset.createSubsetTransform)({
    typed: _functionsAny.typed,
    matrix: _functionsAny.matrix
  }),
  sum:
  /* #__PURE__ */
  (0, _sum.createSumTransform)({
    typed: _functionsAny.typed,
    config: _functionsAny.config,
    add: _functionsAny.add,
    bignumber: _functionsAny.bignumber,
    fraction: _functionsAny.fraction
  }),
  std:
  /* #__PURE__ */
  (0, _std.createStdTransform)({
    typed: _functionsAny.typed,
    sqrt: _functionsAny.sqrt,
    variance: _functionsAny.variance
  }),
  variance:
  /* #__PURE__ */
  (0, _variance.createVarianceTransform)({
    typed: _functionsAny.typed,
    add: _functionsAny.add,
    subtract: _functionsAny.subtract,
    multiply: _functionsAny.multiply,
    divide: _functionsAny.divide,
    apply: _functionsAny.apply,
    isNaN: _functionsAny.isNaN
  })
});

Chain.createProxy(math);