@ohif/app 3.7.0-beta.40 → 3.7.0-beta.41

package/dist/{926.bundle.dbc9d0e591cb9217fda2.js → 220.bundle.f7e1c96c94245e70f2be.js}

@@ -1,6 +1,6 @@
-(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[926],{
+(self["webpackChunk"] = self["webpackChunk"] || []).push([[220],{
 
-/***/ 36953:
+/***/ 45730:
 /***/ (function(module, exports) {
 
 var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/**
@@ -1425,7 +1425,7 @@ var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/**
 
 /***/ }),
 
-/***/ 65020:
+/***/ 93907:
 /***/ ((module) => {
 
 "use strict";
@@ -1512,7 +1512,7 @@ module.exports = function (str) {
 
 /***/ }),
 
-/***/ 39429:
+/***/ 1638:
 /***/ (function(module, exports) {
 
 var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/**
@@ -2404,7 +2404,7 @@ var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/**
 
 /***/ }),
 
-/***/ 55263:
+/***/ 74681:
 /***/ ((module) => {
 
 /*
@@ -2456,7 +2456,7 @@ module.exports = function naturalSort (a, b) {
 
 /***/ }),
 
-/***/ 90567:
+/***/ 89757:
 /***/ ((module) => {
 
 function E () {
@@ -2530,7 +2530,7 @@ module.exports.TinyEmitter = E;
 
 /***/ }),
 
-/***/ 29926:
+/***/ 55220:
 /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -2541,10 +2541,10 @@ __webpack_require__.d(__webpack_exports__, {
   JpY: () => (/* reexport */ multiply)
 });
 
-// UNUSED EXPORTS: AccessorNode, AccessorNodeDependencies, ArgumentsError, ArrayNode, ArrayNodeDependencies, AssignmentNode, AssignmentNodeDependencies, BigNumber, BigNumberDependencies, BlockNode, BlockNodeDependencies, Chain, ChainDependencies, Complex, ComplexDependencies, ConditionalNode, ConditionalNodeDependencies, ConstantNode, ConstantNodeDependencies, DenseMatrix, DenseMatrixDependencies, DimensionError, EDependencies, FibonacciHeap, FibonacciHeapDependencies, Fraction, FractionDependencies, FunctionAssignmentNode, FunctionAssignmentNodeDependencies, FunctionNode, FunctionNodeDependencies, Help, HelpDependencies, ImmutableDenseMatrix, ImmutableDenseMatrixDependencies, Index, IndexDependencies, IndexError, IndexNode, IndexNodeDependencies, InfinityDependencies, LN10, LN10Dependencies, LN2, LN2Dependencies, LOG10E, LOG10EDependencies, LOG2E, LOG2EDependencies, Matrix, MatrixDependencies, NaNDependencies, Node, NodeDependencies, ObjectNode, ObjectNodeDependencies, OperatorNode, OperatorNodeDependencies, PIDependencies, ParenthesisNode, ParenthesisNodeDependencies, Parser, ParserDependencies, Range, RangeDependencies, RangeNode, RangeNodeDependencies, RelationalNode, RelationalNodeDependencies, ResultSet, ResultSetDependencies, SQRT1_2, SQRT1_2Dependencies, SQRT2, SQRT2Dependencies, Spa, SpaDependencies, SparseMatrix, SparseMatrixDependencies, SymbolNode, SymbolNodeDependencies, Unit, UnitDependencies, _Infinity, _NaN, _false, _null, _true, abs, absDependencies, acos, acosDependencies, acosh, acoshDependencies, acot, acotDependencies, acoth, acothDependencies, acsc, acscDependencies, acsch, acschDependencies, add, addDependencies, addScalar, addScalarDependencies, all, and, andDependencies, apply, applyDependencies, applyTransformDependencies, arg, argDependencies, asec, asecDependencies, asech, asechDependencies, asin, asinDependencies, asinh, asinhDependencies, atan, atan2, atan2Dependencies, atanDependencies, atanh, atanhDependencies, atomicMass, atomicMassDependencies, avogadro, avogadroDependencies, bellNumbers, bellNumbersDependencies, bignumber, bignumberDependencies, bin, binDependencies, bitAnd, bitAndDependencies, bitNot, bitNotDependencies, bitOr, bitOrDependencies, bitXor, bitXorDependencies, bohrMagneton, bohrMagnetonDependencies, bohrRadius, bohrRadiusDependencies, boltzmann, boltzmannDependencies, boolean, booleanDependencies, catalan, catalanDependencies, cbrt, cbrtDependencies, ceil, ceilDependencies, chain, chainDependencies, classicalElectronRadius, classicalElectronRadiusDependencies, clone, cloneDependencies, column, columnDependencies, columnTransformDependencies, combinations, combinationsDependencies, combinationsWithRep, combinationsWithRepDependencies, compare, compareDependencies, compareNatural, compareNaturalDependencies, compareText, compareTextDependencies, compile, compileDependencies, complex, complexDependencies, composition, compositionDependencies, concat, concatDependencies, concatTransformDependencies, conductanceQuantum, conductanceQuantumDependencies, config, conj, conjDependencies, cos, cosDependencies, cosh, coshDependencies, cot, cotDependencies, coth, cothDependencies, coulomb, coulombDependencies, count, countDependencies, create, createAbs, createAccessorNode, createAcos, createAcosh, createAcot, createAcoth, createAcsc, createAcsch, createAdd, createAddScalar, createAnd, createApply, createApplyTransform, createArg, createArrayNode, createAsec, createAsech, createAsin, createAsinh, createAssignmentNode, createAtan, createAtan2, createAtanh, createAtomicMass, createAvogadro, createBellNumbers, createBigNumberClass, createBignumber, createBin, createBitAnd, createBitNot, createBitOr, createBitXor, createBlockNode, createBohrMagneton, createBohrRadius, createBoltzmann, createBoolean, createCatalan, createCbrt, createCeil, createChain, createChainClass, createClassicalElectronRadius, createClone, createColumn, createColumnTransform, createCombinations, createCombinationsWithRep, createCompare, createCompareNatural, createCompareText, createCompile, createComplex, createComplexClass, createComposition, createConcat, createConcatTransform, createConditionalNode, createConductanceQuantum, createConj, createConstantNode, createCos, createCosh, createCot, createCoth, createCoulomb, createCount, createCreateUnit, createCross, createCsc, createCsch, createCtranspose, createCube, createCumSum, createCumSumTransform, createDeepEqual, createDenseMatrixClass, createDerivative, createDet, createDeuteronMass, createDiag, createDiff, createDiffTransform, createDistance, createDivide, createDivideScalar, createDot, createDotDivide, createDotMultiply, createDotPow, createE, createEfimovFactor, createEigs, createElectricConstant, createElectronMass, createElementaryCharge, createEqual, createEqualScalar, createEqualText, createErf, createEvaluate, createExp, createExpm, createExpm1, createFactorial, createFalse, createFaraday, createFermiCoupling, createFft, createFibonacciHeapClass, createFilter, createFilterTransform, createFineStructure, createFirstRadiation, createFix, createFlatten, createFloor, createForEach, createForEachTransform, createFormat, createFraction, createFractionClass, createFunctionAssignmentNode, createFunctionNode, createGamma, createGasConstant, createGcd, createGetMatrixDataType, createGravitationConstant, createGravity, createHartreeEnergy, createHasNumericValue, createHelp, createHelpClass, createHex, createHypot, createI, createIdentity, createIfft, createIm, createImmutableDenseMatrixClass, createIndex, createIndexClass, createIndexNode, createIndexTransform, createInfinity, createIntersect, createInv, createInverseConductanceQuantum, createInvmod, createIsInteger, createIsNaN, createIsNegative, createIsNumeric, createIsPositive, createIsPrime, createIsZero, createKldivergence, createKlitzing, createKron, createLN10, createLN2, createLOG10E, createLOG2E, createLarger, createLargerEq, createLcm, createLeafCount, createLeftShift, createLgamma, createLog, createLog10, createLog1p, createLog2, createLoschmidt, createLsolve, createLsolveAll, createLup, createLusolve, createLyap, createMad, createMagneticConstant, createMagneticFluxQuantum, createMap, createMapTransform, createMatrix, createMatrixClass, createMatrixFromColumns, createMatrixFromFunction, createMatrixFromRows, createMax, createMaxTransform, createMean, createMeanTransform, createMedian, createMin, createMinTransform, createMod, createMode, createMolarMass, createMolarMassC12, createMolarPlanckConstant, createMolarVolume, createMultinomial, createMultiply, createMultiplyScalar, createNaN, createNeutronMass, createNode, createNorm, createNot, createNthRoot, createNthRoots, createNuclearMagneton, createNull, createNumber, createNumeric, createObjectNode, createOct, createOnes, createOperatorNode, createOr, createParenthesisNode, createParse, createParser, createParserClass, createPartitionSelect, createPermutations, createPhi, createPi, createPickRandom, createPinv, createPlanckCharge, createPlanckConstant, createPlanckLength, createPlanckMass, createPlanckTemperature, createPlanckTime, createPolynomialRoot, createPow, createPrint, createProd, createProtonMass, createQr, createQuantileSeq, createQuantumOfCirculation, createRandom, createRandomInt, createRange, createRangeClass, createRangeNode, createRangeTransform, createRationalize, createRe, createReducedPlanckConstant, createRelationalNode, createReplacer, createReshape, createResize, createResolve, createResultSet, createReviver, createRightArithShift, createRightLogShift, createRotate, createRotationMatrix, createRound, createRow, createRowTransform, createRydberg, createSQRT1_2, createSQRT2, createSackurTetrode, createSchur, createSec, createSech, createSecondRadiation, createSetCartesian, createSetDifference, createSetDistinct, createSetIntersect, createSetIsSubset, createSetMultiplicity, createSetPowerset, createSetSize, createSetSymDifference, createSetUnion, createSign, createSimplify, createSimplifyConstant, createSimplifyCore, createSin, createSinh, createSize, createSlu, createSmaller, createSmallerEq, createSort, createSpaClass, createSparse, createSparseMatrixClass, createSpeedOfLight, createSplitUnit, createSqrt, createSqrtm, createSquare, createSqueeze, createStd, createStdTransform, createStefanBoltzmann, createStirlingS2, createString, createSubset, createSubsetTransform, createSubtract, createSum, createSumTransform, createSylvester, createSymbolNode, createSymbolicEqual, createTan, createTanh, createTau, createThomsonCrossSection, createTo, createTrace, createTranspose, createTrue, createTypeOf, createTyped, createUnaryMinus, createUnaryPlus, createUnequal, createUnit, createUnitClass, createUnitDependencies, createUnitFunction, createUppercaseE, createUppercasePi, createUsolve, createUsolveAll, createVacuumImpedance, createVariance, createVarianceTransform, createVersion, createWeakMixingAngle, createWienDisplacement, createXgcd, createXor, createZeros, cross, crossDependencies, csc, cscDependencies, csch, cschDependencies, ctranspose, ctransposeDependencies, cube, cubeDependencies, cumsum, cumsumDependencies, cumsumTransformDependencies, deepEqual, deepEqualDependencies, derivative, derivativeDependencies, det, detDependencies, deuteronMass, deuteronMassDependencies, diag, diagDependencies, diff, diffDependencies, diffTransformDependencies, distance, distanceDependencies, divide, divideDependencies, divideScalar, divideScalarDependencies, docs, dot, dotDependencies, dotDivide, dotDivideDependencies, dotMultiply, dotMultiplyDependencies, dotPow, dotPowDependencies, e, eDependencies, efimovFactor, efimovFactorDependencies, eigs, eigsDependencies, electricConstant, electricConstantDependencies, electronMass, electronMassDependencies, elementaryCharge, elementaryChargeDependencies, equal, equalDependencies, equalScalar, equalScalarDependencies, equalText, equalTextDependencies, erf, erfDependencies, evaluate, evaluateDependencies, exp, expDependencies, expm, expm1, expm1Dependencies, expmDependencies, factorial, factorialDependencies, factory, falseDependencies, faraday, faradayDependencies, fermiCoupling, fermiCouplingDependencies, fft, fftDependencies, filter, filterDependencies, filterTransformDependencies, fineStructure, fineStructureDependencies, firstRadiation, firstRadiationDependencies, fix, fixDependencies, flatten, flattenDependencies, floor, floorDependencies, forEach, forEachDependencies, forEachTransformDependencies, format, formatDependencies, fraction, fractionDependencies, gamma, gammaDependencies, gasConstant, gasConstantDependencies, gcd, gcdDependencies, getMatrixDataType, getMatrixDataTypeDependencies, gravitationConstant, gravitationConstantDependencies, gravity, gravityDependencies, hartreeEnergy, hartreeEnergyDependencies, hasNumericValue, hasNumericValueDependencies, help, helpDependencies, hex, hexDependencies, hypot, hypotDependencies, i, iDependencies, identity, identityDependencies, ifft, ifftDependencies, im, imDependencies, index, indexDependencies, indexTransformDependencies, intersect, intersectDependencies, invDependencies, inverseConductanceQuantum, inverseConductanceQuantumDependencies, invmod, invmodDependencies, isAccessorNode, isArray, isArrayNode, isAssignmentNode, isBigNumber, isBlockNode, isBoolean, isChain, isCollection, isComplex, isConditionalNode, isConstantNode, isDate, isDenseMatrix, isFraction, isFunction, isFunctionAssignmentNode, isFunctionNode, isHelp, isIndex, isIndexNode, isInteger, isIntegerDependencies, isMatrix, isNaN, isNaNDependencies, isNegative, isNegativeDependencies, isNode, isNull, isNumber, isNumeric, isNumericDependencies, isObject, isObjectNode, isOperatorNode, isParenthesisNode, isPositive, isPositiveDependencies, isPrime, isPrimeDependencies, isRange, isRangeNode, isRegExp, isRelationalNode, isResultSet, isSparseMatrix, isString, isSymbolNode, isUndefined, isUnit, isZero, isZeroDependencies, kldivergence, kldivergenceDependencies, klitzing, klitzingDependencies, kron, kronDependencies, larger, largerDependencies, largerEq, largerEqDependencies, lcm, lcmDependencies, leafCount, leafCountDependencies, leftShift, leftShiftDependencies, lgamma, lgammaDependencies, log, log10, log10Dependencies, log1p, log1pDependencies, log2, log2Dependencies, logDependencies, loschmidt, loschmidtDependencies, lsolve, lsolveAll, lsolveAllDependencies, lsolveDependencies, lup, lupDependencies, lusolve, lusolveDependencies, lyap, lyapDependencies, mad, madDependencies, magneticConstant, magneticConstantDependencies, magneticFluxQuantum, magneticFluxQuantumDependencies, map, mapDependencies, mapTransformDependencies, matrix, matrixDependencies, matrixFromColumns, matrixFromColumnsDependencies, matrixFromFunction, matrixFromFunctionDependencies, matrixFromRows, matrixFromRowsDependencies, max, maxDependencies, maxTransformDependencies, mean, meanDependencies, meanTransformDependencies, median, medianDependencies, min, minDependencies, minTransformDependencies, mod, modDependencies, mode, modeDependencies, molarMass, molarMassC12, molarMassC12Dependencies, molarMassDependencies, molarPlanckConstant, molarPlanckConstantDependencies, molarVolume, molarVolumeDependencies, multinomial, multinomialDependencies, multiplyDependencies, multiplyScalar, multiplyScalarDependencies, neutronMass, neutronMassDependencies, norm, normDependencies, not, notDependencies, nthRoot, nthRootDependencies, nthRoots, nthRootsDependencies, nuclearMagneton, nuclearMagnetonDependencies, nullDependencies, number, numberDependencies, numeric, numericDependencies, oct, octDependencies, ones, onesDependencies, or, orDependencies, parse, parseDependencies, parser, parserDependencies, partitionSelect, partitionSelectDependencies, permutations, permutationsDependencies, phi, phiDependencies, pi, piDependencies, pickRandom, pickRandomDependencies, pinv, pinvDependencies, planckCharge, planckChargeDependencies, planckConstant, planckConstantDependencies, planckLength, planckLengthDependencies, planckMass, planckMassDependencies, planckTemperature, planckTemperatureDependencies, planckTime, planckTimeDependencies, polynomialRoot, polynomialRootDependencies, pow, powDependencies, print, printDependencies, prod, prodDependencies, protonMass, protonMassDependencies, qr, qrDependencies, quantileSeq, quantileSeqDependencies, quantumOfCirculation, quantumOfCirculationDependencies, random, randomDependencies, randomInt, randomIntDependencies, range, rangeDependencies, rangeTransformDependencies, rationalize, rationalizeDependencies, re, reDependencies, reducedPlanckConstant, reducedPlanckConstantDependencies, replacer, replacerDependencies, reshape, reshapeDependencies, resize, resizeDependencies, resolve, resolveDependencies, reviver, reviverDependencies, rightArithShift, rightArithShiftDependencies, rightLogShift, rightLogShiftDependencies, rotate, rotateDependencies, rotationMatrix, rotationMatrixDependencies, round, roundDependencies, row, rowDependencies, rowTransformDependencies, rydberg, rydbergDependencies, sackurTetrode, sackurTetrodeDependencies, schur, schurDependencies, sec, secDependencies, sech, sechDependencies, secondRadiation, secondRadiationDependencies, setCartesian, setCartesianDependencies, setDifference, setDifferenceDependencies, setDistinct, setDistinctDependencies, setIntersect, setIntersectDependencies, setIsSubset, setIsSubsetDependencies, setMultiplicity, setMultiplicityDependencies, setPowerset, setPowersetDependencies, setSize, setSizeDependencies, setSymDifference, setSymDifferenceDependencies, setUnion, setUnionDependencies, sign, signDependencies, simplify, simplifyConstant, simplifyConstantDependencies, simplifyCore, simplifyCoreDependencies, simplifyDependencies, sin, sinDependencies, sinh, sinhDependencies, size, sizeDependencies, slu, sluDependencies, smaller, smallerDependencies, smallerEq, smallerEqDependencies, sort, sortDependencies, sparse, sparseDependencies, speedOfLight, speedOfLightDependencies, splitUnit, splitUnitDependencies, sqrt, sqrtDependencies, sqrtm, sqrtmDependencies, square, squareDependencies, squeeze, squeezeDependencies, std, stdDependencies, stdTransformDependencies, stefanBoltzmann, stefanBoltzmannDependencies, stirlingS2, stirlingS2Dependencies, string, stringDependencies, subset, subsetDependencies, subsetTransformDependencies, subtract, subtractDependencies, sum, sumDependencies, sumTransformDependencies, sylvester, sylvesterDependencies, symbolicEqual, symbolicEqualDependencies, tan, tanDependencies, tanh, tanhDependencies, tau, tauDependencies, thomsonCrossSection, thomsonCrossSectionDependencies, to, toDependencies, trace, traceDependencies, transpose, transposeDependencies, trueDependencies, typeOf, typeOfDependencies, typed, typedDependencies, unaryMinus, unaryMinusDependencies, unaryPlus, unaryPlusDependencies, unequal, unequalDependencies, unit, unitDependencies, usolve, usolveAll, usolveAllDependencies, usolveDependencies, vacuumImpedance, vacuumImpedanceDependencies, variance, varianceDependencies, varianceTransformDependencies, version, versionDependencies, weakMixingAngle, weakMixingAngleDependencies, wienDisplacement, wienDisplacementDependencies, xgcd, xgcdDependencies, xor, xorDependencies, zeros, zerosDependencies
+// UNUSED EXPORTS: AccessorNode, AccessorNodeDependencies, ArgumentsError, ArrayNode, ArrayNodeDependencies, AssignmentNode, AssignmentNodeDependencies, BigNumber, BigNumberDependencies, BlockNode, BlockNodeDependencies, Chain, ChainDependencies, Complex, ComplexDependencies, ConditionalNode, ConditionalNodeDependencies, ConstantNode, ConstantNodeDependencies, DenseMatrix, DenseMatrixDependencies, DimensionError, EDependencies, FibonacciHeap, FibonacciHeapDependencies, Fraction, FractionDependencies, FunctionAssignmentNode, FunctionAssignmentNodeDependencies, FunctionNode, FunctionNodeDependencies, Help, HelpDependencies, ImmutableDenseMatrix, ImmutableDenseMatrixDependencies, Index, IndexDependencies, IndexError, IndexNode, IndexNodeDependencies, InfinityDependencies, LN10, LN10Dependencies, LN2, LN2Dependencies, LOG10E, LOG10EDependencies, LOG2E, LOG2EDependencies, Matrix, MatrixDependencies, NaNDependencies, Node, NodeDependencies, ObjectNode, ObjectNodeDependencies, OperatorNode, OperatorNodeDependencies, PIDependencies, ParenthesisNode, ParenthesisNodeDependencies, Parser, ParserDependencies, Range, RangeDependencies, RangeNode, RangeNodeDependencies, RelationalNode, RelationalNodeDependencies, ResultSet, ResultSetDependencies, SQRT1_2, SQRT1_2Dependencies, SQRT2, SQRT2Dependencies, Spa, SpaDependencies, SparseMatrix, SparseMatrixDependencies, SymbolNode, SymbolNodeDependencies, Unit, UnitDependencies, _Infinity, _NaN, _false, _null, _true, abs, absDependencies, acos, acosDependencies, acosh, acoshDependencies, acot, acotDependencies, acoth, acothDependencies, acsc, acscDependencies, acsch, acschDependencies, add, addDependencies, addScalar, addScalarDependencies, all, and, andDependencies, apply, applyDependencies, applyTransformDependencies, arg, argDependencies, asec, asecDependencies, asech, asechDependencies, asin, asinDependencies, asinh, asinhDependencies, atan, atan2, atan2Dependencies, atanDependencies, atanh, atanhDependencies, atomicMass, atomicMassDependencies, avogadro, avogadroDependencies, bellNumbers, bellNumbersDependencies, bignumber, bignumberDependencies, bin, binDependencies, bitAnd, bitAndDependencies, bitNot, bitNotDependencies, bitOr, bitOrDependencies, bitXor, bitXorDependencies, bohrMagneton, bohrMagnetonDependencies, bohrRadius, bohrRadiusDependencies, boltzmann, boltzmannDependencies, boolean, booleanDependencies, catalan, catalanDependencies, cbrt, cbrtDependencies, ceil, ceilDependencies, chain, chainDependencies, classicalElectronRadius, classicalElectronRadiusDependencies, clone, cloneDependencies, column, columnDependencies, columnTransformDependencies, combinations, combinationsDependencies, combinationsWithRep, combinationsWithRepDependencies, compare, compareDependencies, compareNatural, compareNaturalDependencies, compareText, compareTextDependencies, compile, compileDependencies, complex, complexDependencies, composition, compositionDependencies, concat, concatDependencies, concatTransformDependencies, conductanceQuantum, conductanceQuantumDependencies, config, conj, conjDependencies, cos, cosDependencies, cosh, coshDependencies, cot, cotDependencies, coth, cothDependencies, coulomb, coulombDependencies, count, countDependencies, create, createAbs, createAccessorNode, createAcos, createAcosh, createAcot, createAcoth, createAcsc, createAcsch, createAdd, createAddScalar, createAnd, createApply, createApplyTransform, createArg, createArrayNode, createAsec, createAsech, createAsin, createAsinh, createAssignmentNode, createAtan, createAtan2, createAtanh, createAtomicMass, createAvogadro, createBellNumbers, createBigNumberClass, createBignumber, createBin, createBitAnd, createBitNot, createBitOr, createBitXor, createBlockNode, createBohrMagneton, createBohrRadius, createBoltzmann, createBoolean, createCatalan, createCbrt, createCeil, createChain, createChainClass, createClassicalElectronRadius, createClone, createColumn, createColumnTransform, createCombinations, createCombinationsWithRep, createCompare, createCompareNatural, createCompareText, createCompile, createComplex, createComplexClass, createComposition, createConcat, createConcatTransform, createConditionalNode, createConductanceQuantum, createConj, createConstantNode, createCos, createCosh, createCot, createCoth, createCoulomb, createCount, createCreateUnit, createCross, createCsc, createCsch, createCtranspose, createCube, createCumSum, createCumSumTransform, createDeepEqual, createDenseMatrixClass, createDerivative, createDet, createDeuteronMass, createDiag, createDiff, createDiffTransform, createDistance, createDivide, createDivideScalar, createDot, createDotDivide, createDotMultiply, createDotPow, createE, createEfimovFactor, createEigs, createElectricConstant, createElectronMass, createElementaryCharge, createEqual, createEqualScalar, createEqualText, createErf, createEvaluate, createExp, createExpm, createExpm1, createFactorial, createFalse, createFaraday, createFermiCoupling, createFft, createFibonacciHeapClass, createFilter, createFilterTransform, createFineStructure, createFirstRadiation, createFix, createFlatten, createFloor, createForEach, createForEachTransform, createFormat, createFraction, createFractionClass, createFreqz, createFunctionAssignmentNode, createFunctionNode, createGamma, createGasConstant, createGcd, createGetMatrixDataType, createGravitationConstant, createGravity, createHartreeEnergy, createHasNumericValue, createHelp, createHelpClass, createHex, createHypot, createI, createIdentity, createIfft, createIm, createImmutableDenseMatrixClass, createIndex, createIndexClass, createIndexNode, createIndexTransform, createInfinity, createIntersect, createInv, createInverseConductanceQuantum, createInvmod, createIsInteger, createIsNaN, createIsNegative, createIsNumeric, createIsPositive, createIsPrime, createIsZero, createKldivergence, createKlitzing, createKron, createLN10, createLN2, createLOG10E, createLOG2E, createLarger, createLargerEq, createLcm, createLeafCount, createLeftShift, createLgamma, createLog, createLog10, createLog1p, createLog2, createLoschmidt, createLsolve, createLsolveAll, createLup, createLusolve, createLyap, createMad, createMagneticConstant, createMagneticFluxQuantum, createMap, createMapTransform, createMatrix, createMatrixClass, createMatrixFromColumns, createMatrixFromFunction, createMatrixFromRows, createMax, createMaxTransform, createMean, createMeanTransform, createMedian, createMin, createMinTransform, createMod, createMode, createMolarMass, createMolarMassC12, createMolarPlanckConstant, createMolarVolume, createMultinomial, createMultiply, createMultiplyScalar, createNaN, createNeutronMass, createNode, createNorm, createNot, createNthRoot, createNthRoots, createNuclearMagneton, createNull, createNumber, createNumeric, createObjectNode, createOct, createOnes, createOperatorNode, createOr, createParenthesisNode, createParse, createParser, createParserClass, createPartitionSelect, createPermutations, createPhi, createPi, createPickRandom, createPinv, createPlanckCharge, createPlanckConstant, createPlanckLength, createPlanckMass, createPlanckTemperature, createPlanckTime, createPolynomialRoot, createPow, createPrint, createProd, createProtonMass, createQr, createQuantileSeq, createQuantumOfCirculation, createRandom, createRandomInt, createRange, createRangeClass, createRangeNode, createRangeTransform, createRationalize, createRe, createReducedPlanckConstant, createRelationalNode, createReplacer, createReshape, createResize, createResolve, createResultSet, createReviver, createRightArithShift, createRightLogShift, createRotate, createRotationMatrix, createRound, createRow, createRowTransform, createRydberg, createSQRT1_2, createSQRT2, createSackurTetrode, createSchur, createSec, createSech, createSecondRadiation, createSetCartesian, createSetDifference, createSetDistinct, createSetIntersect, createSetIsSubset, createSetMultiplicity, createSetPowerset, createSetSize, createSetSymDifference, createSetUnion, createSign, createSimplify, createSimplifyConstant, createSimplifyCore, createSin, createSinh, createSize, createSlu, createSmaller, createSmallerEq, createSolveODE, createSort, createSpaClass, createSparse, createSparseMatrixClass, createSpeedOfLight, createSplitUnit, createSqrt, createSqrtm, createSquare, createSqueeze, createStd, createStdTransform, createStefanBoltzmann, createStirlingS2, createString, createSubset, createSubsetTransform, createSubtract, createSum, createSumTransform, createSylvester, createSymbolNode, createSymbolicEqual, createTan, createTanh, createTau, createThomsonCrossSection, createTo, createTrace, createTranspose, createTrue, createTypeOf, createTyped, createUnaryMinus, createUnaryPlus, createUnequal, createUnit, createUnitClass, createUnitDependencies, createUnitFunction, createUppercaseE, createUppercasePi, createUsolve, createUsolveAll, createVacuumImpedance, createVariance, createVarianceTransform, createVersion, createWeakMixingAngle, createWienDisplacement, createXgcd, createXor, createZeros, createZpk2tf, cross, crossDependencies, csc, cscDependencies, csch, cschDependencies, ctranspose, ctransposeDependencies, cube, cubeDependencies, cumsum, cumsumDependencies, cumsumTransformDependencies, deepEqual, deepEqualDependencies, derivative, derivativeDependencies, det, detDependencies, deuteronMass, deuteronMassDependencies, diag, diagDependencies, diff, diffDependencies, diffTransformDependencies, distance, distanceDependencies, divide, divideDependencies, divideScalar, divideScalarDependencies, docs, dot, dotDependencies, dotDivide, dotDivideDependencies, dotMultiply, dotMultiplyDependencies, dotPow, dotPowDependencies, e, eDependencies, efimovFactor, efimovFactorDependencies, eigs, eigsDependencies, electricConstant, electricConstantDependencies, electronMass, electronMassDependencies, elementaryCharge, elementaryChargeDependencies, equal, equalDependencies, equalScalar, equalScalarDependencies, equalText, equalTextDependencies, erf, erfDependencies, evaluate, evaluateDependencies, exp, expDependencies, expm, expm1, expm1Dependencies, expmDependencies, factorial, factorialDependencies, factory, falseDependencies, faraday, faradayDependencies, fermiCoupling, fermiCouplingDependencies, fft, fftDependencies, filter, filterDependencies, filterTransformDependencies, fineStructure, fineStructureDependencies, firstRadiation, firstRadiationDependencies, fix, fixDependencies, flatten, flattenDependencies, floor, floorDependencies, forEach, forEachDependencies, forEachTransformDependencies, format, formatDependencies, fraction, fractionDependencies, freqz, freqzDependencies, gamma, gammaDependencies, gasConstant, gasConstantDependencies, gcd, gcdDependencies, getMatrixDataType, getMatrixDataTypeDependencies, gravitationConstant, gravitationConstantDependencies, gravity, gravityDependencies, hartreeEnergy, hartreeEnergyDependencies, hasNumericValue, hasNumericValueDependencies, help, helpDependencies, hex, hexDependencies, hypot, hypotDependencies, i, iDependencies, identity, identityDependencies, ifft, ifftDependencies, im, imDependencies, index, indexDependencies, indexTransformDependencies, intersect, intersectDependencies, invDependencies, inverseConductanceQuantum, inverseConductanceQuantumDependencies, invmod, invmodDependencies, isAccessorNode, isArray, isArrayNode, isAssignmentNode, isBigNumber, isBlockNode, isBoolean, isChain, isCollection, isComplex, isConditionalNode, isConstantNode, isDate, isDenseMatrix, isFraction, isFunction, isFunctionAssignmentNode, isFunctionNode, isHelp, isIndex, isIndexNode, isInteger, isIntegerDependencies, isMatrix, isNaN, isNaNDependencies, isNegative, isNegativeDependencies, isNode, isNull, isNumber, isNumeric, isNumericDependencies, isObject, isObjectNode, isOperatorNode, isParenthesisNode, isPositive, isPositiveDependencies, isPrime, isPrimeDependencies, isRange, isRangeNode, isRegExp, isRelationalNode, isResultSet, isSparseMatrix, isString, isSymbolNode, isUndefined, isUnit, isZero, isZeroDependencies, kldivergence, kldivergenceDependencies, klitzing, klitzingDependencies, kron, kronDependencies, larger, largerDependencies, largerEq, largerEqDependencies, lcm, lcmDependencies, leafCount, leafCountDependencies, leftShift, leftShiftDependencies, lgamma, lgammaDependencies, log, log10, log10Dependencies, log1p, log1pDependencies, log2, log2Dependencies, logDependencies, loschmidt, loschmidtDependencies, lsolve, lsolveAll, lsolveAllDependencies, lsolveDependencies, lup, lupDependencies, lusolve, lusolveDependencies, lyap, lyapDependencies, mad, madDependencies, magneticConstant, magneticConstantDependencies, magneticFluxQuantum, magneticFluxQuantumDependencies, map, mapDependencies, mapTransformDependencies, matrix, matrixDependencies, matrixFromColumns, matrixFromColumnsDependencies, matrixFromFunction, matrixFromFunctionDependencies, matrixFromRows, matrixFromRowsDependencies, max, maxDependencies, maxTransformDependencies, mean, meanDependencies, meanTransformDependencies, median, medianDependencies, min, minDependencies, minTransformDependencies, mod, modDependencies, mode, modeDependencies, molarMass, molarMassC12, molarMassC12Dependencies, molarMassDependencies, molarPlanckConstant, molarPlanckConstantDependencies, molarVolume, molarVolumeDependencies, multinomial, multinomialDependencies, multiplyDependencies, multiplyScalar, multiplyScalarDependencies, neutronMass, neutronMassDependencies, norm, normDependencies, not, notDependencies, nthRoot, nthRootDependencies, nthRoots, nthRootsDependencies, nuclearMagneton, nuclearMagnetonDependencies, nullDependencies, number, numberDependencies, numeric, numericDependencies, oct, octDependencies, ones, onesDependencies, or, orDependencies, parse, parseDependencies, parser, parserDependencies, partitionSelect, partitionSelectDependencies, permutations, permutationsDependencies, phi, phiDependencies, pi, piDependencies, pickRandom, pickRandomDependencies, pinv, pinvDependencies, planckCharge, planckChargeDependencies, planckConstant, planckConstantDependencies, planckLength, planckLengthDependencies, planckMass, planckMassDependencies, planckTemperature, planckTemperatureDependencies, planckTime, planckTimeDependencies, polynomialRoot, polynomialRootDependencies, pow, powDependencies, print, printDependencies, prod, prodDependencies, protonMass, protonMassDependencies, qr, qrDependencies, quantileSeq, quantileSeqDependencies, quantumOfCirculation, quantumOfCirculationDependencies, random, randomDependencies, randomInt, randomIntDependencies, range, rangeDependencies, rangeTransformDependencies, rationalize, rationalizeDependencies, re, reDependencies, reducedPlanckConstant, reducedPlanckConstantDependencies, replacer, replacerDependencies, reshape, reshapeDependencies, resize, resizeDependencies, resolve, resolveDependencies, reviver, reviverDependencies, rightArithShift, rightArithShiftDependencies, rightLogShift, rightLogShiftDependencies, rotate, rotateDependencies, rotationMatrix, rotationMatrixDependencies, round, roundDependencies, row, rowDependencies, rowTransformDependencies, rydberg, rydbergDependencies, sackurTetrode, sackurTetrodeDependencies, schur, schurDependencies, sec, secDependencies, sech, sechDependencies, secondRadiation, secondRadiationDependencies, setCartesian, setCartesianDependencies, setDifference, setDifferenceDependencies, setDistinct, setDistinctDependencies, setIntersect, setIntersectDependencies, setIsSubset, setIsSubsetDependencies, setMultiplicity, setMultiplicityDependencies, setPowerset, setPowersetDependencies, setSize, setSizeDependencies, setSymDifference, setSymDifferenceDependencies, setUnion, setUnionDependencies, sign, signDependencies, simplify, simplifyConstant, simplifyConstantDependencies, simplifyCore, simplifyCoreDependencies, simplifyDependencies, sin, sinDependencies, sinh, sinhDependencies, size, sizeDependencies, slu, sluDependencies, smaller, smallerDependencies, smallerEq, smallerEqDependencies, solveODE, solveODEDependencies, sort, sortDependencies, sparse, sparseDependencies, speedOfLight, speedOfLightDependencies, splitUnit, splitUnitDependencies, sqrt, sqrtDependencies, sqrtm, sqrtmDependencies, square, squareDependencies, squeeze, squeezeDependencies, std, stdDependencies, stdTransformDependencies, stefanBoltzmann, stefanBoltzmannDependencies, stirlingS2, stirlingS2Dependencies, string, stringDependencies, subset, subsetDependencies, subsetTransformDependencies, subtract, subtractDependencies, sum, sumDependencies, sumTransformDependencies, sylvester, sylvesterDependencies, symbolicEqual, symbolicEqualDependencies, tan, tanDependencies, tanh, tanhDependencies, tau, tauDependencies, thomsonCrossSection, thomsonCrossSectionDependencies, to, toDependencies, trace, traceDependencies, transpose, transposeDependencies, trueDependencies, typeOf, typeOfDependencies, typed, typedDependencies, unaryMinus, unaryMinusDependencies, unaryPlus, unaryPlusDependencies, unequal, unequalDependencies, unit, unitDependencies, usolve, usolveAll, usolveAllDependencies, usolveDependencies, vacuumImpedance, vacuumImpedanceDependencies, variance, varianceDependencies, varianceTransformDependencies, version, versionDependencies, weakMixingAngle, weakMixingAngleDependencies, wienDisplacement, wienDisplacementDependencies, xgcd, xgcdDependencies, xor, xorDependencies, zeros, zerosDependencies, zpk2tf, zpk2tfDependencies
 
 // EXTERNAL MODULE: ../../../node_modules/@babel/runtime/helpers/esm/extends.js
-var esm_extends = __webpack_require__(20011);
+var esm_extends = __webpack_require__(76805);
 ;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/core/config.js
 var config_DEFAULT_CONFIG = {
   // minimum relative difference between two compared values,
@@ -6333,7 +6333,7 @@ function formatter_format(value, options) {
     // determine precision from options
     if (typeof options === 'number') {
       precision = options;
-    } else if (options.precision) {
+    } else if (options.precision !== undefined) {
       precision = options.precision;
     }
     if (options.wordSize) {
@@ -6394,7 +6394,7 @@ function formatter_format(value, options) {
 
 /**
  * Format a BigNumber in engineering notation. Like '1.23e+6', '2.3e+0', '3.500e-3'
- * @param {BigNumber | string} value
+ * @param {BigNumber} value
  * @param {number} [precision]        Optional number of significant figures to return.
  */
 function formatter_toEngineering(value, precision) {
@@ -6406,7 +6406,8 @@ function formatter_toEngineering(value, precision) {
   var valueWithoutExp = value.mul(Math.pow(10, -newExp));
   var valueStr = valueWithoutExp.toPrecision(precision);
   if (valueStr.indexOf('e') !== -1) {
-    valueStr = valueWithoutExp.toString();
+    var BigNumber = value.constructor;
+    valueStr = new BigNumber(valueStr).toFixed();
   }
   return valueStr + 'e' + (e >= 0 ? '+' : '') + newExp.toString();
 }
@@ -7489,12 +7490,13 @@ function isSafeProperty(object, prop) {
  * Throws an error when that's not the case.
  * @param {Object} object
  * @param {string} method
+ * @return {function} Returns the method when valid
  */
-// TODO: merge this function into assign.js?
-function validateSafeMethod(object, method) {
+function getSafeMethod(object, method) {
   if (!isSafeMethod(object, method)) {
     throw new Error('No access to method "' + method + '"');
   }
+  return object[method];
 }
 
 /**
@@ -13117,7 +13119,7 @@ var createBigNumberClass = /* #__PURE__ */factory_factory(BigNumber_name, BigNum
   isClass: true
 });
 // EXTERNAL MODULE: ../../../node_modules/complex.js/complex.js
-var complex = __webpack_require__(36953);
+var complex = __webpack_require__(45730);
 ;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/type/complex/Complex.js
 
 
@@ -13314,7 +13316,7 @@ var createComplexClass = /* #__PURE__ */factory_factory(Complex_name, Complex_de
   isClass: true
 });
 // EXTERNAL MODULE: ../../../node_modules/fraction.js/fraction.js
-var fraction = __webpack_require__(39429);
+var fraction = __webpack_require__(1638);
 ;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/type/fraction/Fraction.js
 
 
@@ -18063,9 +18065,11 @@ var createNumber = /* #__PURE__ */factory_factory(number_name, number_dependenci
     Fraction: function Fraction(x) {
       return x.valueOf();
     },
-    Unit: function Unit(x) {
-      throw new Error('Second argument with valueless unit expected');
-    },
+    Unit: typed.referToSelf(self => x => {
+      var clone = x.clone();
+      clone.value = self(x.value);
+      return clone;
+    }),
     null: function _null(x) {
       return 0;
     },
@@ -18277,6 +18281,11 @@ var createBignumber = /* #__PURE__ */factory_factory(bignumber_name, bignumber_d
       // we assume a BigNumber is immutable
       return x;
     },
+    Unit: typed.referToSelf(self => x => {
+      var clone = x.clone();
+      clone.value = self(x.value);
+      return clone;
+    }),
     Fraction: function Fraction(x) {
       return new BigNumber(x.n).div(x.d).times(x.s);
     },
@@ -18415,7 +18424,7 @@ var createFraction = /* #__PURE__ */factory_factory(fraction_name, fraction_depe
    *
    *    bignumber, number, string, unit
    *
-   * @param {number | string | Fraction | BigNumber | Array | Matrix} [args]
+   * @param {number | string | Fraction | BigNumber | Unit | Array | Matrix} [args]
    *            Arguments specifying the value, or numerator and denominator of
    *            the fraction
    * @return {Fraction | Array | Matrix} Returns a fraction
@@ -18443,6 +18452,11 @@ var createFraction = /* #__PURE__ */factory_factory(fraction_name, fraction_depe
       return x; // fractions are immutable
     },
 
+    Unit: typed.referToSelf(self => x => {
+      var clone = x.clone();
+      clone.value = self(x.value);
+      return clone;
+    }),
     Object: function Object(x) {
       return new Fraction(x);
     },
@@ -18788,7 +18802,7 @@ var createSplitUnit = /* #__PURE__ */factory_factory(splitUnit_name, splitUnit_d
    *
    * Syntax:
    *
-   *     splitUnit(unit: Unit, parts: Array.<Unit>)
+   *     math.splitUnit(unit: Unit, parts: Array.<Unit>)
    *
    * Example:
    *
@@ -25262,6 +25276,74 @@ var createDiag = /* #__PURE__ */factory_factory(diag_name, diag_dependencies, _r
     return format !== null ? matrix(vector) : vector;
   }
 });
+;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/utils/applyCallback.js
+
+
+
+/**
+ * Invoke a callback for functions like map and filter with a matching number of arguments
+ * @param {function} callback
+ * @param {any} value
+ * @param {number | number[]} index
+ * @param {Array} array
+ * @param {string} mappingFnName   The name of the function that is invoking these callbacks, for example "map" or "filter"
+ * @returns {*}
+ */
+function applyCallback(callback, value, index, array, mappingFnName) {
+  if (typed_function.isTypedFunction(callback)) {
+    // invoke the typed callback function with the matching number of arguments only
+
+    var args3 = [value, index, array];
+    var signature3 = typed_function.resolve(callback, args3);
+    if (signature3) {
+      return tryWithArgs(signature3.implementation, args3);
+    }
+    var args2 = [value, index];
+    var signature2 = typed_function.resolve(callback, args2);
+    if (signature2) {
+      return tryWithArgs(signature2.implementation, args2);
+    }
+    var args1 = [value];
+    var signature1 = typed_function.resolve(callback, args1);
+    if (signature1) {
+      return tryWithArgs(signature1.implementation, args1);
+    }
+
+    // fallback (will throw an exception)
+    return tryWithArgs(callback, args3);
+  } else {
+    // A regular JavaScript function
+    return callback(value, index, array);
+  }
+
+  /**
+   * @param {function} signature The selected signature of the typed-function
+   * @param {Array} args List with arguments to apply to the selected signature
+   * @returns {*} Returns the return value of the invoked signature
+   * @throws {TypeError} Throws an error when no matching signature was found
+   */
+  function tryWithArgs(signature, args) {
+    try {
+      return signature.apply(signature, args);
+    } catch (err) {
+      var _err$data;
+      // Enrich the error message so the user understands that it took place inside the callback function
+      if (err instanceof TypeError && ((_err$data = err.data) === null || _err$data === void 0 ? void 0 : _err$data.category) === 'wrongType') {
+        var argsDesc = [];
+        argsDesc.push("value: ".concat(typeOf(value)));
+        if (args.length >= 2) {
+          argsDesc.push("index: ".concat(typeOf(index)));
+        }
+        if (args.length >= 3) {
+          argsDesc.push("array: ".concat(typeOf(array)));
+        }
+        throw new TypeError("Function ".concat(mappingFnName, " cannot apply callback arguments ") + "".concat(callback.name, "(").concat(argsDesc.join(', '), ") at index ").concat(JSON.stringify(index)));
+      } else {
+        throw new TypeError("Function ".concat(mappingFnName, " cannot apply callback arguments ") + "to function ".concat(callback.name, ": ").concat(err.message));
+      }
+    }
+  }
+}
 ;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/function/matrix/filter.js
 
 
@@ -25321,18 +25403,9 @@ var createFilter = /* #__PURE__ */factory_factory(filter_name, filter_dependenci
  * @private
  */
 function _filterCallback(x, callback) {
-  // figure out what number of arguments the callback function expects
-  var args = maxArgumentCount(callback);
   return filter(x, function (value, index, array) {
     // invoke the callback function with the right number of arguments
-    if (args === 1) {
-      return callback(value);
-    } else if (args === 2) {
-      return callback(value, [index]);
-    } else {
-      // 3 or -1
-      return callback(value, [index], array);
-    }
+    return applyCallback(callback, value, [index], array, 'filter');
   });
 }
 ;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/function/matrix/flatten.js
@@ -25417,14 +25490,12 @@ var createForEach = /* #__PURE__ */factory_factory(forEach_name, forEach_depende
 });
 
 /**
- * forEach for a multi dimensional array
+ * forEach for a multidimensional array
  * @param {Array} array
  * @param {Function} callback
  * @private
  */
 function _forEach(array, callback) {
-  // figure out what number of arguments the callback function expects
-  var args = maxArgumentCount(callback);
   var recurse = function recurse(value, index) {
     if (Array.isArray(value)) {
       forEach(value, function (child, i) {
@@ -25433,14 +25504,7 @@ function _forEach(array, callback) {
       });
     } else {
       // invoke the callback function with the right number of arguments
-      if (args === 1) {
-        callback(value);
-      } else if (args === 2) {
-        callback(value, index);
-      } else {
-        // 3 or -1
-        callback(value, index, array);
-      }
+      return applyCallback(callback, value, index, array, 'forEach');
     }
   };
   recurse(array, []);
@@ -25751,14 +25815,9 @@ var map_createMap = /* #__PURE__ */factory_factory(map_name, map_dependencies, _
    *      return value * value
    *    })  // returns [1, 4, 9]
    *
-   *    // The calling convention for the callback can cause subtleties:
-   *    math.map([1, 2, 3], math.format)
-   *    // throws TypeError: map attempted to call 'format(1,[0])' but argument 2 of type Array does not match expected type number or function or Object or string or boolean
-   *    // [This happens because `format` _can_ take a second argument,
-   *    // but its semantics don't match that of the 2nd argument `map` provides]
-   *
-   *    // To avoid this error, use a function that takes exactly the
-   *    // desired arguments:
+   *    // The callback is normally called with three arguments:
+   *    //    callback(value, index, Array)
+   *    // If you want to call with only one argument, use:
    *    math.map([1, 2, 3], x => math.format(x)) // returns ['1', '2', '3']
    *
    * See also:
@@ -25787,8 +25846,6 @@ var map_createMap = /* #__PURE__ */factory_factory(map_name, map_dependencies, _
  * @private
  */
 function _map(array, callback) {
-  // figure out what number of arguments the callback function expects
-  var args = maxArgumentCount(callback);
   var recurse = function recurse(value, index) {
     if (Array.isArray(value)) {
       return value.map(function (child, i) {
@@ -25796,33 +25853,8 @@ function _map(array, callback) {
         return recurse(child, index.concat(i));
       });
     } else {
-      try {
-        // invoke the callback function with the right number of arguments
-        if (args === 1) {
-          return callback(value);
-        } else if (args === 2) {
-          return callback(value, index);
-        } else {
-          // 3 or -1
-          return callback(value, index, array);
-        }
-      } catch (err) {
-        // But maybe the arguments still weren't right
-        if (err instanceof TypeError && 'data' in err && err.data.category === 'wrongType') {
-          var newmsg = "map attempted to call '".concat(err.data.fn, "(").concat(value);
-          var indexString = JSON.stringify(index);
-          if (args === 2) {
-            newmsg += ',' + indexString;
-          } else if (args !== 1) {
-            newmsg += ",".concat(indexString, ",").concat(array);
-          }
-          newmsg += ")' but argument ".concat(err.data.index + 1, " of type ");
-          newmsg += "".concat(err.data.actual, " does not match expected type ");
-          newmsg += err.data.expected.join(' or ');
-          throw new TypeError(newmsg);
-        }
-        throw err;
-      }
+      // invoke the callback function with the right number of arguments
+      return applyCallback(callback, value, index, array, 'map');
     }
   };
   return recurse(array, []);
@@ -26137,7 +26169,7 @@ function noSubset() {
 
 
 var range_name = 'range';
-var range_dependencies = ['typed', 'config', '?matrix', '?bignumber', 'smaller', 'smallerEq', 'larger', 'largerEq'];
+var range_dependencies = ['typed', 'config', '?matrix', '?bignumber', 'smaller', 'smallerEq', 'larger', 'largerEq', 'add', 'isPositive'];
 var createRange = /* #__PURE__ */factory_factory(range_name, range_dependencies, _ref => {
   var {
     typed,
@@ -26147,7 +26179,9 @@ var createRange = /* #__PURE__ */factory_factory(range_name, range_dependencies,
     smaller,
     smallerEq,
     larger,
-    largerEq
+    largerEq,
+    add,
+    isPositive
   } = _ref;
   /**
    * Create an array from a range.
@@ -26169,11 +26203,11 @@ var createRange = /* #__PURE__ */factory_factory(range_name, range_dependencies,
    *
    * - `str: string`
    *   A string 'start:end' or 'start:step:end'
-   * - `start: {number | BigNumber}`
+   * - `start: {number | BigNumber | Unit}`
    *   Start of the range
-   * - `end: number | BigNumber`
+   * - `end: number | BigNumber | Unit`
    *   End of the range, excluded by default, included when parameter includeEnd=true
-   * - `step: number | BigNumber`
+   * - `step: number | BigNumber | Unit`
    *   Step size. Default value is 1.
    * - `includeEnd: boolean`
    *   Option to specify whether to include the end or not. False by default.
@@ -26184,6 +26218,7 @@ var createRange = /* #__PURE__ */factory_factory(range_name, range_dependencies,
    *     math.range(2, -3, -1)   // [2, 1, 0, -1, -2]
    *     math.range('2:1:6')     // [2, 3, 4, 5]
    *     math.range(2, 6, true)  // [2, 3, 4, 5, 6]
+   *     math.range(math.unit(2, 'm'), math.unit(-3, 'm'), math.unit(-1, 'm')) // [2 m, 1 m, 0 m , -1 m, -2 m]
    *
    * See also:
    *
@@ -26199,30 +26234,36 @@ var createRange = /* #__PURE__ */factory_factory(range_name, range_dependencies,
     string: _strRange,
     'string, boolean': _strRange,
     'number, number': function numberNumber(start, end) {
-      return _out(_rangeEx(start, end, 1));
+      return _out(_range(start, end, 1, false));
     },
     'number, number, number': function numberNumberNumber(start, end, step) {
-      return _out(_rangeEx(start, end, step));
+      return _out(_range(start, end, step, false));
     },
     'number, number, boolean': function numberNumberBoolean(start, end, includeEnd) {
-      return includeEnd ? _out(_rangeInc(start, end, 1)) : _out(_rangeEx(start, end, 1));
+      return _out(_range(start, end, 1, includeEnd));
     },
     'number, number, number, boolean': function numberNumberNumberBoolean(start, end, step, includeEnd) {
-      return includeEnd ? _out(_rangeInc(start, end, step)) : _out(_rangeEx(start, end, step));
+      return _out(_range(start, end, step, includeEnd));
     },
     'BigNumber, BigNumber': function BigNumberBigNumber(start, end) {
       var BigNumber = start.constructor;
-      return _out(_bigRangeEx(start, end, new BigNumber(1)));
+      return _out(_range(start, end, new BigNumber(1), false));
     },
     'BigNumber, BigNumber, BigNumber': function BigNumberBigNumberBigNumber(start, end, step) {
-      return _out(_bigRangeEx(start, end, step));
+      return _out(_range(start, end, step, false));
     },
     'BigNumber, BigNumber, boolean': function BigNumberBigNumberBoolean(start, end, includeEnd) {
       var BigNumber = start.constructor;
-      return includeEnd ? _out(_bigRangeInc(start, end, new BigNumber(1))) : _out(_bigRangeEx(start, end, new BigNumber(1)));
+      return _out(_range(start, end, new BigNumber(1), includeEnd));
     },
     'BigNumber, BigNumber, BigNumber, boolean': function BigNumberBigNumberBigNumberBoolean(start, end, step, includeEnd) {
-      return includeEnd ? _out(_bigRangeInc(start, end, step)) : _out(_bigRangeEx(start, end, step));
+      return _out(_range(start, end, step, includeEnd));
+    },
+    'Unit, Unit, Unit': function UnitUnitUnit(start, end, step) {
+      return _out(_range(start, end, step, false));
+    },
+    'Unit, Unit, Unit, boolean': function UnitUnitUnitBoolean(start, end, step, includeEnd) {
+      return _out(_range(start, end, step, includeEnd));
     }
   });
   function _out(arr) {
@@ -26236,117 +26277,32 @@ var createRange = /* #__PURE__ */factory_factory(range_name, range_dependencies,
     if (!r) {
       throw new SyntaxError('String "' + str + '" is no valid range');
     }
-    var fn;
     if (config.number === 'BigNumber') {
       if (bignumber === undefined) {
         noBignumber();
       }
-      fn = includeEnd ? _bigRangeInc : _bigRangeEx;
-      return _out(fn(bignumber(r.start), bignumber(r.end), bignumber(r.step)));
+      return _out(_range(bignumber(r.start), bignumber(r.end), bignumber(r.step)), includeEnd);
     } else {
-      fn = includeEnd ? _rangeInc : _rangeEx;
-      return _out(fn(r.start, r.end, r.step));
+      return _out(_range(r.start, r.end, r.step, includeEnd));
     }
   }
 
   /**
-   * Create a range with numbers. End is excluded
-   * @param {number} start
-   * @param {number} end
-   * @param {number} step
+   * Create a range with numbers or BigNumbers
+   * @param {number | BigNumber | Unit} start
+   * @param {number | BigNumber | Unit} end
+   * @param {number | BigNumber | Unit} step
+   * @param {boolean} includeEnd
    * @returns {Array} range
    * @private
    */
-  function _rangeEx(start, end, step) {
+  function _range(start, end, step, includeEnd) {
     var array = [];
+    var ongoing = isPositive(step) ? includeEnd ? smallerEq : smaller : includeEnd ? largerEq : larger;
     var x = start;
-    if (step > 0) {
-      while (smaller(x, end)) {
-        array.push(x);
-        x += step;
-      }
-    } else if (step < 0) {
-      while (larger(x, end)) {
-        array.push(x);
-        x += step;
-      }
-    }
-    return array;
-  }
-
-  /**
-   * Create a range with numbers. End is included
-   * @param {number} start
-   * @param {number} end
-   * @param {number} step
-   * @returns {Array} range
-   * @private
-   */
-  function _rangeInc(start, end, step) {
-    var array = [];
-    var x = start;
-    if (step > 0) {
-      while (smallerEq(x, end)) {
-        array.push(x);
-        x += step;
-      }
-    } else if (step < 0) {
-      while (largerEq(x, end)) {
-        array.push(x);
-        x += step;
-      }
-    }
-    return array;
-  }
-
-  /**
-   * Create a range with big numbers. End is excluded
-   * @param {BigNumber} start
-   * @param {BigNumber} end
-   * @param {BigNumber} step
-   * @returns {Array} range
-   * @private
-   */
-  function _bigRangeEx(start, end, step) {
-    var zero = bignumber(0);
-    var array = [];
-    var x = start;
-    if (step.gt(zero)) {
-      while (smaller(x, end)) {
-        array.push(x);
-        x = x.plus(step);
-      }
-    } else if (step.lt(zero)) {
-      while (larger(x, end)) {
-        array.push(x);
-        x = x.plus(step);
-      }
-    }
-    return array;
-  }
-
-  /**
-   * Create a range with big numbers. End is included
-   * @param {BigNumber} start
-   * @param {BigNumber} end
-   * @param {BigNumber} step
-   * @returns {Array} range
-   * @private
-   */
-  function _bigRangeInc(start, end, step) {
-    var zero = bignumber(0);
-    var array = [];
-    var x = start;
-    if (step.gt(zero)) {
-      while (smallerEq(x, end)) {
-        array.push(x);
-        x = x.plus(step);
-      }
-    } else if (step.lt(zero)) {
-      while (largerEq(x, end)) {
-        array.push(x);
-        x = x.plus(step);
-      }
+    while (ongoing(x, end)) {
+      array.push(x);
+      x = add(x, step);
     }
     return array;
   }
@@ -27680,6 +27636,293 @@ var createIfft = /* #__PURE__ */factory_factory(ifft_name, ifft_dependencies, _r
     }
   });
 });
+// EXTERNAL MODULE: ../../../node_modules/@babel/runtime/helpers/esm/defineProperty.js
+var defineProperty = __webpack_require__(87765);
+;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/function/numeric/solveODE.js
+
+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) { (0,defineProperty/* default */.Z)(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; }
+
+
+var solveODE_name = 'solveODE';
+var solveODE_dependencies = ['typed', 'add', 'subtract', 'multiply', 'divide', 'max', 'map', 'abs', 'isPositive', 'isNegative', 'larger', 'smaller', 'matrix', 'bignumber', 'unaryMinus'];
+var createSolveODE = /* #__PURE__ */factory_factory(solveODE_name, solveODE_dependencies, _ref => {
+  var {
+    typed,
+    add,
+    subtract,
+    multiply,
+    divide,
+    max,
+    map,
+    abs,
+    isPositive,
+    isNegative,
+    larger,
+    smaller,
+    matrix,
+    bignumber,
+    unaryMinus
+  } = _ref;
+  /**
+     * Numerical Integration of Ordinary Differential Equations
+     *
+     * Two variable step methods are provided:
+     * - "RK23": Bogacki–Shampine method
+     * - "RK45": Dormand-Prince method RK5(4)7M (default)
+     *
+     * The arguments are expected as follows.
+     *
+     * - `func` should be the forcing function `f(t, y)`
+     * - `tspan` should be a vector of two numbers or units `[tStart, tEnd]`
+     * - `y0` the initial state values, should be a scalar or a flat array
+     * - `options` should be an object with the following information:
+     *   - `method` ('RK45'): ['RK23', 'RK45']
+     *   - `tol` (1e-3): Numeric tolerance of the method, the solver keeps the error estimates less than this value
+     *   - `firstStep`: Initial step size
+     *   - `minStep`: minimum step size of the method
+     *   - `maxStep`: maximum step size of the method
+     *   - `minDelta` (0.2): minimum ratio of change for the step
+     *   - `maxDelta` (5): maximum ratio of change for the step
+     *   - `maxIter` (1e4): maximum number of iterations
+     *
+     * The returned value is an object with `{t, y}` please note that even though `t` means time, it can represent any other independant variable like `x`:
+     * - `t` an array of size `[n]`
+     * - `y` the states array can be in two ways
+     *   - **if `y0` is a scalar:** returns an array-like of size `[n]`
+     *   - **if `y0` is a flat array-like of size [m]:** returns an array like of size `[n, m]`
+     *
+     * Syntax:
+     *
+     *     math.solveODE(func, tspan, y0)
+     *     math.solveODE(func, tspan, y0, options)
+     *
+     * Examples:
+     *
+     *     function func(t, y) {return y}
+     *     const tspan = [0, 4]
+     *     const y0 = 1
+     *     math.solveODE(func, tspan, y0)
+     *     math.solveODE(func, tspan, [1, 2])
+     *     math.solveODE(func, tspan, y0, { method:"RK23", maxStep:0.1 })
+     *
+     * See also:
+     *
+     *     derivative, simplifyCore
+     *
+     * @param {function} func The forcing function f(t,y)
+     * @param {Array | Matrix} tspan The time span
+     * @param {number | BigNumber | Unit | Array | Matrix} y0 The initial value
+     * @param {Object} [options] Optional configuration options
+     * @return {Object} Return an object with t and y values as arrays
+     */
+
+  function _rk(butcherTableau) {
+    // generates an adaptive runge kutta method from it's butcher tableau
+
+    return function (f, tspan, y0, options) {
+      // adaptive runge kutta methods
+      var wrongTSpan = !(tspan.length === 2 && (tspan.every(isNumOrBig) || tspan.every(is_isUnit)));
+      if (wrongTSpan) {
+        throw new Error('"tspan" must be an Array of two numeric values or two units [tStart, tEnd]');
+      }
+      var t0 = tspan[0]; // initial time
+      var tf = tspan[1]; // final time
+      var isForwards = larger(tf, t0);
+      var firstStep = options.firstStep;
+      if (firstStep !== undefined && !isPositive(firstStep)) {
+        throw new Error('"firstStep" must be positive');
+      }
+      var maxStep = options.maxStep;
+      if (maxStep !== undefined && !isPositive(maxStep)) {
+        throw new Error('"maxStep" must be positive');
+      }
+      var minStep = options.minStep;
+      if (minStep && isNegative(minStep)) {
+        throw new Error('"minStep" must be positive or zero');
+      }
+      var timeVars = [t0, tf, firstStep, minStep, maxStep].filter(x => x !== undefined);
+      if (!(timeVars.every(isNumOrBig) || timeVars.every(is_isUnit))) {
+        throw new Error('Inconsistent type of "t" dependant variables');
+      }
+      var steps = 1; // divide time in this number of steps
+      var tol = options.tol ? options.tol : 1e-4; // define a tolerance (must be an option)
+      var minDelta = options.minDelta ? options.minDelta : 0.2;
+      var maxDelta = options.maxDelta ? options.maxDelta : 5;
+      var maxIter = options.maxIter ? options.maxIter : 10000; // stop inifite evaluation if something goes wrong
+      var hasBigNumbers = [t0, tf, ...y0, maxStep, minStep].some(is_isBigNumber);
+      var [a, c, b, bp] = hasBigNumbers ? [bignumber(butcherTableau.a), bignumber(butcherTableau.c), bignumber(butcherTableau.b), bignumber(butcherTableau.bp)] : [butcherTableau.a, butcherTableau.c, butcherTableau.b, butcherTableau.bp];
+      var h = firstStep ? isForwards ? firstStep : unaryMinus(firstStep) : divide(subtract(tf, t0), steps); // define the first step size
+      var t = [t0]; // start the time array
+      var y = [y0]; // start the solution array
+
+      var deltaB = subtract(b, bp); // b - bp
+
+      var n = 0;
+      var iter = 0;
+      var ongoing = _createOngoing(isForwards);
+      var trimStep = _createTrimStep(isForwards);
+      // iterate unitil it reaches either the final time or maximum iterations
+      while (ongoing(t[n], tf)) {
+        var k = [];
+
+        // trim the time step so that it doesn't overshoot
+        h = trimStep(t[n], tf, h);
+
+        // calculate the first value of k
+        k.push(f(t[n], y[n]));
+
+        // calculate the rest of the values of k
+        for (var i = 1; i < c.length; ++i) {
+          k.push(f(add(t[n], multiply(c[i], h)), add(y[n], multiply(h, a[i], k))));
+        }
+
+        // estimate the error by comparing solutions of different orders
+        var TE = max(abs(map(multiply(deltaB, k), X => is_isUnit(X) ? X.value : X)));
+        if (TE < tol && tol / TE > 1 / 4) {
+          // push solution if within tol
+          t.push(add(t[n], h));
+          y.push(add(y[n], multiply(h, b, k)));
+          n++;
+        }
+
+        // estimate the delta value that will affect the step size
+        var delta = 0.84 * (tol / TE) ** (1 / 5);
+        if (smaller(delta, minDelta)) {
+          delta = minDelta;
+        } else if (larger(delta, maxDelta)) {
+          delta = maxDelta;
+        }
+        delta = hasBigNumbers ? bignumber(delta) : delta;
+        h = multiply(h, delta);
+        if (maxStep && larger(abs(h), maxStep)) {
+          h = isForwards ? maxStep : unaryMinus(maxStep);
+        } else if (minStep && smaller(abs(h), minStep)) {
+          h = isForwards ? minStep : unaryMinus(minStep);
+        }
+        iter++;
+        if (iter > maxIter) {
+          throw new Error('Maximum number of iterations reached, try changing options');
+        }
+      }
+      return {
+        t,
+        y
+      };
+    };
+  }
+  function _rk23(f, tspan, y0, options) {
+    // Bogacki–Shampine method
+
+    // Define the butcher table
+    var a = [[], [1 / 2], [0, 3 / 4], [2 / 9, 1 / 3, 4 / 9]];
+    var c = [null, 1 / 2, 3 / 4, 1];
+    var b = [2 / 9, 1 / 3, 4 / 9, 0];
+    var bp = [7 / 24, 1 / 4, 1 / 3, 1 / 8];
+    var butcherTableau = {
+      a,
+      c,
+      b,
+      bp
+    };
+
+    // Solve an adaptive step size rk method
+    return _rk(butcherTableau)(f, tspan, y0, options);
+  }
+  function _rk45(f, tspan, y0, options) {
+    // Dormand Prince method
+
+    // Define the butcher tableau
+    var a = [[], [1 / 5], [3 / 40, 9 / 40], [44 / 45, -56 / 15, 32 / 9], [19372 / 6561, -25360 / 2187, 64448 / 6561, -212 / 729], [9017 / 3168, -355 / 33, 46732 / 5247, 49 / 176, -5103 / 18656], [35 / 384, 0, 500 / 1113, 125 / 192, -2187 / 6784, 11 / 84]];
+    var c = [null, 1 / 5, 3 / 10, 4 / 5, 8 / 9, 1, 1];
+    var b = [35 / 384, 0, 500 / 1113, 125 / 192, -2187 / 6784, 11 / 84, 0];
+    var bp = [5179 / 57600, 0, 7571 / 16695, 393 / 640, -92097 / 339200, 187 / 2100, 1 / 40];
+    var butcherTableau = {
+      a,
+      c,
+      b,
+      bp
+    };
+
+    // Solve an adaptive step size rk method
+    return _rk(butcherTableau)(f, tspan, y0, options);
+  }
+  function _solveODE(f, tspan, y0, opt) {
+    var method = opt.method ? opt.method : 'RK45';
+    var methods = {
+      RK23: _rk23,
+      RK45: _rk45
+    };
+    if (method.toUpperCase() in methods) {
+      var methodOptions = _objectSpread({}, opt); // clone the options object
+      delete methodOptions.method; // delete the method as it won't be needed
+      return methods[method.toUpperCase()](f, tspan, y0, methodOptions);
+    } else {
+      // throw an error indicating there is no such method
+      var methodsWithQuotes = Object.keys(methods).map(x => "\"".concat(x, "\""));
+      // generates a string of methods like: "BDF", "RK23" and "RK45"
+      var availableMethodsString = "".concat(methodsWithQuotes.slice(0, -1).join(', '), " and ").concat(methodsWithQuotes.slice(-1));
+      throw new Error("Unavailable method \"".concat(method, "\". Available methods are ").concat(availableMethodsString));
+    }
+  }
+  function _createOngoing(isForwards) {
+    // returns the correct function to test if it's still iterating
+    return isForwards ? smaller : larger;
+  }
+  function _createTrimStep(isForwards) {
+    var outOfBounds = isForwards ? larger : smaller;
+    return function (t, tf, h) {
+      var next = add(t, h);
+      return outOfBounds(next, tf) ? subtract(tf, t) : h;
+    };
+  }
+  function isNumOrBig(x) {
+    // checks if it's a number or bignumber
+    return is_isBigNumber(x) || is_isNumber(x);
+  }
+  function _matrixSolveODE(f, T, y0, options) {
+    // receives matrices and returns matrices
+    var sol = _solveODE(f, T.toArray(), y0.toArray(), options);
+    return {
+      t: matrix(sol.t),
+      y: matrix(sol.y)
+    };
+  }
+  return typed('solveODE', {
+    'function, Array, Array, Object': _solveODE,
+    'function, Matrix, Matrix, Object': _matrixSolveODE,
+    'function, Array, Array': (f, T, y0) => _solveODE(f, T, y0, {}),
+    'function, Matrix, Matrix': (f, T, y0) => _matrixSolveODE(f, T, y0, {}),
+    'function, Array, number | BigNumber | Unit': (f, T, y0) => {
+      var sol = _solveODE(f, T, [y0], {});
+      return {
+        t: sol.t,
+        y: sol.y.map(Y => Y[0])
+      };
+    },
+    'function, Matrix, number | BigNumber | Unit': (f, T, y0) => {
+      var sol = _solveODE(f, T.toArray(), [y0], {});
+      return {
+        t: matrix(sol.t),
+        y: matrix(sol.y.map(Y => Y[0]))
+      };
+    },
+    'function, Array, number | BigNumber | Unit, Object': (f, T, y0, options) => {
+      var sol = _solveODE(f, T, [y0], options);
+      return {
+        t: sol.t,
+        y: sol.y.map(Y => Y[0])
+      };
+    },
+    'function, Matrix, number | BigNumber | Unit, Object': (f, T, y0, options) => {
+      var sol = _solveODE(f, T.toArray(), [y0], options);
+      return {
+        t: matrix(sol.t),
+        y: matrix(sol.y.map(Y => Y[0]))
+      };
+    }
+  });
+});
 ;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/function/special/erf.js
 /* eslint-disable no-loss-of-precision */
 
@@ -30983,7 +31226,7 @@ var createCompareNumber = /* #__PURE__ */factory_factory(compare_name, ['typed',
   });
 });
 // EXTERNAL MODULE: ../../../node_modules/javascript-natural-sort/naturalSort.js
-var naturalSort = __webpack_require__(55263);
+var naturalSort = __webpack_require__(74681);
 ;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/function/relational/compareNatural.js
 
 
@@ -33494,8 +33737,6 @@ var createSpaClass = /* #__PURE__ */factory_factory(Spa_name, Spa_dependencies,
 }, {
   isClass: true
 });
-// EXTERNAL MODULE: ../../../node_modules/@babel/runtime/helpers/esm/defineProperty.js
-var defineProperty = __webpack_require__(47169);
 ;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/utils/bignumber/constants.js
 
 
@@ -33557,8 +33798,8 @@ function hasher(args) {
 ;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/type/unit/Unit.js
 
 
-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) { (0,defineProperty/* default */.Z)(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; }
+function Unit_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 Unit_objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? Unit_ownKeys(Object(source), !0).forEach(function (key) { (0,defineProperty/* default */.Z)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : Unit_ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
 
 
@@ -33582,12 +33823,12 @@ var createUnitClass = /* #__PURE__ */factory_factory(Unit_name, Unit_dependencie
     equal,
     isNumeric,
     format,
-    number,
+    number: _number,
     Complex,
     BigNumber: _BigNumber,
     Fraction: _Fraction
   } = _ref;
-  var toNumber = number;
+  var toNumber = _number;
   /**
    * A unit can be constructed in the following ways:
    *
@@ -34168,7 +34409,7 @@ var createUnitClass = /* #__PURE__ */factory_factory(Unit_name, Unit_dependencie
     // Append other's units list onto res
     for (var _i = 0; _i < other.units.length; _i++) {
       // Make a shallow copy of every unit
-      var inverted = _objectSpread({}, other.units[_i]);
+      var inverted = Unit_objectSpread({}, other.units[_i]);
       res.units.push(inverted);
     }
 
@@ -34214,7 +34455,7 @@ var createUnitClass = /* #__PURE__ */factory_factory(Unit_name, Unit_dependencie
     // Invert and append other's units list onto res
     for (var _i2 = 0; _i2 < other.units.length; _i2++) {
       // Make a shallow copy of every unit
-      var inverted = _objectSpread(_objectSpread({}, other.units[_i2]), {}, {
+      var inverted = Unit_objectSpread(Unit_objectSpread({}, other.units[_i2]), {}, {
         power: -other.units[_i2].power
       });
       res.units.push(inverted);
@@ -34337,13 +34578,13 @@ var createUnitClass = /* #__PURE__ */factory_factory(Unit_name, Unit_dependencie
       /* Need to adjust value by difference in offset to convert */
       var convert = Unit._getNumberConverter(typeOf(value)); // convert to Fraction or BigNumber if needed
 
-      var thisUnitValue = convert(this.units[0].unit.value);
-      var thisNominalOffset = convert(this.units[0].unit.offset);
+      var thisUnitValue = this.units[0].unit.value;
+      var thisNominalOffset = this.units[0].unit.offset;
       var thisUnitOffset = multiplyScalar(thisUnitValue, thisNominalOffset);
-      var otherUnitValue = convert(other.units[0].unit.value);
-      var otherNominalOffset = convert(other.units[0].unit.offset);
+      var otherUnitValue = other.units[0].unit.value;
+      var otherNominalOffset = other.units[0].unit.offset;
       var otherUnitOffset = multiplyScalar(otherUnitValue, otherNominalOffset);
-      other.value = subtract(addScalar(value, thisUnitOffset), otherUnitOffset);
+      other.value = addScalar(value, convert(subtract(thisUnitOffset, otherUnitOffset)));
     }
     other.fixPrefix = true;
     other.skipAutomaticSimplification = true;
@@ -36291,8 +36532,8 @@ var createUnitClass = /* #__PURE__ */factory_factory(Unit_name, Unit_dependencie
     },
     // Temperature
     // K(C) = °C + 273.15
-    // K(F) = (°F + 459.67) / 1.8
-    // K(R) = °R / 1.8
+    // K(F) = (°F + 459.67) * (5 / 9)
+    // K(R) = °R * (5 / 9)
     K: {
       name: 'K',
       base: BASE_UNITS.TEMPERATURE,
@@ -36311,14 +36552,14 @@ var createUnitClass = /* #__PURE__ */factory_factory(Unit_name, Unit_dependencie
       name: 'degF',
       base: BASE_UNITS.TEMPERATURE,
       prefixes: PREFIXES.SHORT,
-      value: 1 / 1.8,
+      value: new _Fraction(5, 9),
       offset: 459.67
     },
     degR: {
       name: 'degR',
       base: BASE_UNITS.TEMPERATURE,
       prefixes: PREFIXES.SHORT,
-      value: 1 / 1.8,
+      value: new _Fraction(5, 9),
       offset: 0
     },
     kelvin: {
@@ -36339,14 +36580,14 @@ var createUnitClass = /* #__PURE__ */factory_factory(Unit_name, Unit_dependencie
       name: 'fahrenheit',
       base: BASE_UNITS.TEMPERATURE,
       prefixes: PREFIXES.LONG,
-      value: 1 / 1.8,
+      value: new _Fraction(5, 9),
       offset: 459.67
     },
     rankine: {
       name: 'rankine',
       base: BASE_UNITS.TEMPERATURE,
       prefixes: PREFIXES.LONG,
-      value: 1 / 1.8,
+      value: new _Fraction(5, 9),
       offset: 0
     },
     // amount of substance
@@ -37067,6 +37308,7 @@ var createUnitClass = /* #__PURE__ */factory_factory(Unit_name, Unit_dependencie
    */
   Unit.typeConverters = {
     BigNumber: function BigNumber(x) {
+      if (x !== null && x !== void 0 && x.isFraction) return new _BigNumber(x.n).div(x.d).times(x.s);
       return new _BigNumber(x + ''); // stringify to prevent constructor error
     },
 
@@ -37077,6 +37319,7 @@ var createUnitClass = /* #__PURE__ */factory_factory(Unit_name, Unit_dependencie
       return x;
     },
     number: function number(x) {
+      if (x !== null && x !== void 0 && x.isFraction) return _number(x);
       return x;
     }
   };
@@ -42098,7 +42341,7 @@ var createConditionalNode = /* #__PURE__ */factory_factory(ConditionalNode_name,
   isNode: true
 });
 // EXTERNAL MODULE: ../../../node_modules/escape-latex/dist/index.js
-var dist = __webpack_require__(65020);
+var dist = __webpack_require__(93907);
 ;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/utils/latex.js
 /* eslint no-template-curly-in-string: "off" */
 
@@ -43275,10 +43518,8 @@ var createObjectNode = /* #__PURE__ */factory_factory(ObjectNode_name, ObjectNod
           // so you cannot create a key like {"co\\u006Estructor": null}
           var stringifiedKey = stringify(key);
           var parsedKey = JSON.parse(stringifiedKey);
-          if (!isSafeProperty(this.properties, parsedKey)) {
-            throw new Error('No access to property "' + parsedKey + '"');
-          }
-          evalEntries[parsedKey] = this.properties[key]._compile(math, argNames);
+          var prop = getSafeProperty(this.properties, key);
+          evalEntries[parsedKey] = prop._compile(math, argNames);
         }
       }
       return function evalObjectNode(scope, args, context) {
@@ -44700,7 +44941,7 @@ var createSymbolNode = /* #__PURE__ */factory_factory(SymbolNode_name, SymbolNod
         // (like an x when inside the expression of a function
         // assignment `f(x) = ...`)
         return function (scope, args, context) {
-          return args[name];
+          return getSafeProperty(args, name);
         };
       } else if (name in math) {
         return function (scope, args, context) {
@@ -45061,7 +45302,7 @@ var createFunctionNode = /* #__PURE__ */factory_factory(FunctionNode_name, Funct
           // the function symbol is an argName
           var _rawArgs = this.args;
           return function evalFunctionNode(scope, args, context) {
-            var fn = args[_name];
+            var fn = getSafeProperty(args, _name);
             if (typeof fn !== 'function') {
               throw new TypeError("Argument '".concat(_name, "' was not a function; received: ").concat(strin(fn)));
             }
@@ -45083,15 +45324,14 @@ var createFunctionNode = /* #__PURE__ */factory_factory(FunctionNode_name, Funct
         var _rawArgs2 = this.args;
         return function evalFunctionNode(scope, args, context) {
           var object = evalObject(scope, args, context);
-          validateSafeMethod(object, prop);
-          var isRaw = object[prop] && object[prop].rawArgs;
-          if (isRaw) {
+          var fn = getSafeMethod(object, prop);
+          if (fn !== null && fn !== void 0 && fn.rawArgs) {
             // "Raw" evaluation
-            return object[prop](_rawArgs2, math, createSubScope(scope, args), scope);
+            return fn(_rawArgs2, math, createSubScope(scope, args), scope);
           } else {
             // "regular" evaluation
             var values = evalArgs.map(evalArg => evalArg(scope, args, context));
-            return object[prop].apply(object, values);
+            return fn.apply(object, values);
           }
         };
       } else {
@@ -47131,7 +47371,7 @@ var createParserClass = /* #__PURE__ */factory_factory(Parser_name, Parser_depen
    *    parser.evaluate('f(2, 3)')                // 8
    *
    *    // get and set variables and functions
-   *    const x = parser.get('x')                 // 7
+   *    const x = parser.get('x')                 // 3.5
    *    const f = parser.get('f')                 // function
    *    const g = f(3, 2)                         // 9
    *    parser.set('h', 500)
@@ -47263,7 +47503,7 @@ var createParser = /* #__PURE__ */factory_factory(parser_name, parser_dependenci
    *     parser.evaluate('f(2, 3)')               // 8
    *
    *     // get and set variables and functions
-   *     const x = parser.get('x')                // 7
+   *     const x = parser.get('x')                // 3.5
    *     const f = parser.get('f')                // function
    *     const g = f(3, 2)                        // 9
    *     parser.set('h', 500)
@@ -49825,7 +50065,7 @@ var createPolynomialRoot = /* #__PURE__ */factory_factory(polynomialRoot_name, p
    *
    * Syntax:
    *
-   *     polynomialRoot(constant, linearCoeff, quadraticCoeff, cubicCoeff)
+   *     math.polynomialRoot(constant, linearCoeff, quadraticCoeff, cubicCoeff)
    *
    * Examples:
    *     // linear
@@ -50536,7 +50776,7 @@ var typedDocs = {
   category: 'Core',
   syntax: ['typed(signatures)', 'typed(name, signatures)'],
   description: 'Create a typed function.',
-  examples: ['double = typed({ "number": f(x)=x+x })', 'double(2)', 'double("hello")'],
+  examples: ['double = typed({ "number": f(x)=x+x, "string": f(x)=concat(x,x) })', 'double(2)', 'double("hello")'],
   seealso: []
 };
 ;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/expression/embeddedDocs/function/algebra/derivative.js
@@ -50599,7 +50839,7 @@ var polynomialRootDocs = {
   category: 'Algebra',
   syntax: ['x=polynomialRoot(-6, 3)', 'x=polynomialRoot(4, -4, 1)', 'x=polynomialRoot(-8, 12, -6, 1)'],
   description: 'Finds the roots of a univariate polynomial given by its coefficients starting from constant, linear, and so on, increasing in degree.',
-  examples: ['a = polynomialRoot(-6, 11, -6 1)'],
+  examples: ['a = polynomialRoot(-6, 11, -6, 1)'],
   seealso: ['cbrt', 'sqrt']
 };
 ;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/expression/embeddedDocs/function/algebra/qr.js
@@ -50645,7 +50885,7 @@ var simplifyConstantDocs = {
   category: 'Algebra',
   syntax: ['simplifyConstant(expr)', 'simplifyConstant(expr, options)'],
   description: 'Replace constant subexpressions of node with their values.',
-  examples: ['simplifyConatant("(3-3)*x")', 'simplifyConstant(parse("z-cos(tau/8)"))'],
+  examples: ['simplifyConstant("(3-3)*x")', 'simplifyConstant(parse("z-cos(tau/8)"))'],
   seealso: ['simplify', 'simplifyCore', 'evaluate']
 };
 ;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/expression/embeddedDocs/function/algebra/simplifyCore.js
@@ -50843,7 +51083,7 @@ var invmodDocs = {
   category: 'Arithmetic',
   syntax: ['invmod(a, b)'],
   description: 'Calculate the (modular) multiplicative inverse of a modulo b. Solution to the equation ax ≣ 1 (mod b)',
-  examples: ['invmod(8, 12)=NaN', 'invmod(7, 13)=2', 'invmod(15151, 15122)=10429'],
+  examples: ['invmod(8, 12)', 'invmod(7, 13)', 'invmod(15151, 15122)'],
   seealso: ['gcd', 'xgcd']
 };
 ;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/expression/embeddedDocs/function/arithmetic/lcm.js
@@ -50980,31 +51220,31 @@ var sqrtmDocs = {
   examples: ['sqrtm([[33, 24], [48, 57]])'],
   seealso: ['sqrt', 'abs', 'square', 'multiply']
 };
-;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/expression/embeddedDocs/function/matrix/sylvester.js
+;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/expression/embeddedDocs/function/algebra/sylvester.js
 var sylvesterDocs = {
   name: 'sylvester',
-  category: 'Matrix',
+  category: 'Algebra',
   syntax: ['sylvester(A,B,C)'],
   description: 'Solves the real-valued Sylvester equation AX+XB=C for X',
-  examples: ['sylvester([[-1, -2], [1, 1]], [[-2, 1], [-1, 2]], [[-3, 2], [3, 0]])', 'sylvester(A,B,C)'],
+  examples: ['sylvester([[-1, -2], [1, 1]], [[-2, 1], [-1, 2]], [[-3, 2], [3, 0]])', 'A = [[-1, -2], [1, 1]]; B = [[2, -1], [1, -2]]; C = [[-3, 2], [3, 0]]', 'sylvester(A, B, C)'],
   seealso: ['schur', 'lyap']
 };
-;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/expression/embeddedDocs/function/matrix/schur.js
+;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/expression/embeddedDocs/function/algebra/schur.js
 var schurDocs = {
   name: 'schur',
-  category: 'Matrix',
+  category: 'Algebra',
   syntax: ['schur(A)'],
   description: 'Performs a real Schur decomposition of the real matrix A = UTU\'',
-  examples: ['schur([[1, 0], [-4, 3]])', 'schur(A)'],
+  examples: ['schur([[1, 0], [-4, 3]])', 'A = [[1, 0], [-4, 3]]', 'schur(A)'],
   seealso: ['lyap', 'sylvester']
 };
-;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/expression/embeddedDocs/function/matrix/lyap.js
+;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/expression/embeddedDocs/function/algebra/lyap.js
 var lyapDocs = {
   name: 'lyap',
-  category: 'Matrix',
+  category: 'Algebra',
   syntax: ['lyap(A,Q)'],
   description: 'Solves the Continuous-time Lyapunov equation AP+PA\'+Q=0 for P',
-  examples: ['lyap([[-2, 0], [1, -4]], [[3, 1], [1, 3]])', 'lyap(A,Q)'],
+  examples: ['lyap([[-2, 0], [1, -4]], [[3, 1], [1, 3]])', 'A = [[-2, 0], [1, -4]]', 'Q = [[3, 1], [1, 3]]', 'lyap(A,Q)'],
   seealso: ['schur', 'sylvester']
 };
 ;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/expression/embeddedDocs/function/arithmetic/square.js
@@ -51191,9 +51431,9 @@ var reDocs = {
 var evaluateDocs = {
   name: 'evaluate',
   category: 'Expression',
-  syntax: ['evaluate(expression)', 'evaluate([expr1, expr2, expr3, ...])'],
+  syntax: ['evaluate(expression)', 'evaluate(expression, scope)', 'evaluate([expr1, expr2, expr3, ...])', 'evaluate([expr1, expr2, expr3, ...], scope)'],
   description: 'Evaluate an expression or an array with expressions.',
-  examples: ['evaluate("2 + 3")', 'evaluate("sqrt(" + 4 + ")")'],
+  examples: ['evaluate("2 + 3")', 'evaluate("sqrt(16)")', 'evaluate("2 inch to cm")', 'evaluate("sin(x * pi)", { "x": 1/2 })', 'evaluate(["width=2", "height=4","width*height"])'],
   seealso: []
 };
 ;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/expression/embeddedDocs/function/expression/help.js
@@ -51328,7 +51568,7 @@ var diffDocs = {
   category: 'Matrix',
   syntax: ['diff(arr)', 'diff(arr, dim)'],
   description: ['Create a new matrix or array with the difference of the passed matrix or array.', 'Dim parameter is optional and used to indicant the dimension of the array/matrix to apply the difference', 'If no dimension parameter is passed it is assumed as dimension 0', 'Dimension is zero-based in javascript and one-based in the parser', 'Arrays must be \'rectangular\' meaning arrays like [1, 2]', 'If something is passed as a matrix it will be returned as a matrix but other than that all matrices are converted to arrays'],
-  examples: ['diff([1, 2, 4, 7, 0])', 'diff([1, 2, 4, 7, 0], 0)', 'diff(matrix([1, 2, 4, 7, 0]))', 'diff([[1, 2], [3, 4]])', 'diff([[1, 2], [3, 4]], 0)', 'diff([[1, 2], [3, 4]], 1)', 'diff([[1, 2], [3, 4]], bignumber(1))', 'diff(matrix([[1, 2], [3, 4]]), 1)', 'diff([[1, 2], matrix([3, 4])], 1)'],
+  examples: ['A = [1, 2, 4, 7, 0]', 'diff(A)', 'diff(A, 1)', 'B = [[1, 2], [3, 4]]', 'diff(B)', 'diff(B, 1)', 'diff(B, 2)', 'diff(B, bignumber(2))', 'diff([[1, 2], matrix([3, 4])], 2)'],
   seealso: ['subtract', 'partitionSelect']
 };
 ;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/expression/embeddedDocs/function/matrix/dot.js
@@ -51481,7 +51721,7 @@ var rangeDocs = {
   category: 'Type',
   syntax: ['start:end', 'start:step:end', 'range(start, end)', 'range(start, end, step)', 'range(string)'],
   description: 'Create a range. Lower bound of the range is included, upper bound is excluded.',
-  examples: ['1:5', '3:-1:-3', 'range(3, 7)', 'range(0, 12, 2)', 'range("4:10")', 'a = [1, 2, 3, 4; 5, 6, 7, 8]', 'a[1:2, 1:2]'],
+  examples: ['1:5', '3:-1:-3', 'range(3, 7)', 'range(0, 12, 2)', 'range("4:10")', 'range(1m, 1m, 3m)', 'a = [1, 2, 3, 4; 5, 6, 7, 8]', 'a[1:2, 1:2]'],
   seealso: ['concat', 'det', 'diag', 'identity', 'inv', 'ones', 'size', 'squeeze', 'subset', 'trace', 'transpose', 'zeros']
 };
 ;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/expression/embeddedDocs/function/matrix/reshape.js
@@ -51898,6 +52138,24 @@ var setUnionDocs = {
   examples: ['setUnion([1, 2, 3, 4], [3, 4, 5, 6])', 'setUnion([[1, 2], [3, 4]], [[3, 4], [5, 6]])'],
   seealso: ['setIntersect', 'setDifference']
 };
+;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/expression/embeddedDocs/function/signal/zpk2tf.js
+var zpk2tfDocs = {
+  name: 'zpk2tf',
+  category: 'Signal',
+  syntax: ['zpk2tf(z, p, k)'],
+  description: 'Compute the transfer function of a zero-pole-gain model.',
+  examples: ['zpk2tf([1, 2], [-1, -2], 1)', 'zpk2tf([1, 2], [-1, -2])', 'zpk2tf([1 - 3i, 2 + 2i], [-1, -2])'],
+  seealso: []
+};
+;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/expression/embeddedDocs/function/signal/freqz.js
+var freqzDocs = {
+  name: 'freqz',
+  category: 'Signal',
+  syntax: ['freqz(b, a)', 'freqz(b, a, w)'],
+  description: 'Calculates the frequency response of a filter given its numerator and denominator coefficients.',
+  examples: ['freqz([1, 2], [1, 2, 3])', 'freqz([1, 2], [1, 2, 3], [0, 1])', 'freqz([1, 2], [1, 2, 3], 512)'],
+  seealso: []
+};
 ;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/expression/embeddedDocs/function/special/erf.js
 var erfDocs = {
   name: 'erf',
@@ -52363,7 +52621,7 @@ var numericDocs = {
   category: 'Utils',
   syntax: ['numeric(x)'],
   description: 'Convert a numeric input to a specific numeric type: number, BigNumber, or Fraction.',
-  examples: ['numeric("4")', 'numeric("4", "number")', 'numeric("4", "BigNumber")', 'numeric("4", "Fraction)', 'numeric(4, "Fraction")', 'numeric(fraction(2, 5), "number)'],
+  examples: ['numeric("4")', 'numeric("4", "number")', 'numeric("4", "BigNumber")', 'numeric("4", "Fraction")', 'numeric(4, "Fraction")', 'numeric(fraction(2, 5), "number")'],
   seealso: ['number', 'fraction', 'bignumber', 'string', 'format']
 };
 ;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/expression/embeddedDocs/function/utils/oct.js
@@ -52393,6 +52651,15 @@ var typeOfDocs = {
   examples: ['typeOf(3.5)', 'typeOf(2 - 4i)', 'typeOf(45 deg)', 'typeOf("hello world")'],
   seealso: ['getMatrixDataType']
 };
+;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/expression/embeddedDocs/function/numeric/solveODE.js
+var solveODEDocs = {
+  name: 'solveODE',
+  category: 'Numeric',
+  syntax: ['solveODE(func, tspan, y0)', 'solveODE(func, tspan, y0, options)'],
+  description: 'Numerical Integration of Ordinary Differential Equations.',
+  examples: ['f(t,y) = y', 'tspan = [0, 4]', 'solveODE(f, tspan, 1)', 'solveODE(f, tspan, [1, 2])', 'solveODE(f, tspan, 1, { method:"RK23", maxStep:0.1 })'],
+  seealso: ['derivative', 'simplifyCore']
+};
 ;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/expression/embeddedDocs/embeddedDocs.js
 
 
@@ -52628,6 +52895,9 @@ var typeOfDocs = {
 
 
 
+
+
+
 
 
 
@@ -53003,6 +53273,8 @@ var embeddedDocs = {
   sylvester: sylvesterDocs,
   schur: schurDocs,
   lyap: lyapDocs,
+  // functions - numeric
+  solveODE: solveODEDocs,
   // functions - probability
   combinations: combinationsDocs,
   combinationsWithRep: combinationsWithRepDocs,
@@ -53039,6 +53311,9 @@ var embeddedDocs = {
   setSize: setSizeDocs,
   setSymDifference: setSymDifferenceDocs,
   setUnion: setUnionDocs,
+  // functions - signal
+  zpk2tf: zpk2tfDocs,
+  freqz: freqzDocs,
   // functions - special
   erf: erfDocs,
   // functions - statistics
@@ -55188,7 +55463,7 @@ var createSqrtm = /* #__PURE__ */factory_factory(sqrtm_name, sqrtm_dependencies,
    *
    * Syntax:
    *
-   *     X = math.sqrtm(A)
+   *     math.sqrtm(A)
    *
    * Examples:
    *
@@ -55557,7 +55832,7 @@ var createDivide = /* #__PURE__ */factory_factory(divide_name, divide_dependenci
 
 
 var distance_name = 'distance';
-var distance_dependencies = ['typed', 'addScalar', 'subtract', 'divideScalar', 'multiplyScalar', 'unaryMinus', 'sqrt', 'abs'];
+var distance_dependencies = ['typed', 'addScalar', 'subtract', 'divideScalar', 'multiplyScalar', 'deepEqual', 'sqrt', 'abs'];
 var createDistance = /* #__PURE__ */factory_factory(distance_name, distance_dependencies, _ref => {
   var {
     typed,
@@ -55565,7 +55840,7 @@ var createDistance = /* #__PURE__ */factory_factory(distance_name, distance_depe
     subtract,
     multiplyScalar,
     divideScalar,
-    unaryMinus,
+    deepEqual,
     sqrt,
     abs
   } = _ref;
@@ -55587,10 +55862,10 @@ var createDistance = /* #__PURE__ */factory_factory(distance_name, distance_depe
     *    math.distance([x1,y1,z1,a1], [x2,y2,z2,a2])
     *    math.distance([[x1,y1], [x2,y2], [x3,y3]])
     *    math.distance([[x1,y1,z1], [x2,y2,z2], [x3,y3,z3]])
-    *    math.distance([x1,y1], [x2,y2,z2])
-    *    math.distance([x1,y1], [x2,y2], [x3,y3])
+    *    math.distance([pointX,pointY], [a,b,c])
+    *    math.distance([pointX,pointY], [lineOnePtX,lineOnePtY], [lineTwoPtX,lineTwoPtY])
     *    math.distance({pointX, pointY}, {lineOnePtX, lineOnePtY}, {lineTwoPtX, lineTwoPtY})
-    *    math.distance([x1,y1,z1], [x0, y0, z0, a, b, c])
+    *    math.distance([pointX,pointY,pointZ], [x0, y0, z0, a, b, c])
     *    math.distance({pointX, pointY, pointZ}, {x0, y0, z0, a, b, c})
     *
     * Examples:
@@ -55606,11 +55881,11 @@ var createDistance = /* #__PURE__ */factory_factory(distance_name, distance_depe
     *    math.distance([[1, 2], [1, 2], [1, 3]])         // Returns [0, 1, 1]
     *    math.distance([[1,2,4], [1,2,6], [8,1,3]])      // Returns [2, 7.14142842854285, 7.681145747868608]
     *    math.distance([10, 10], [8, 1, 3])              // Returns 11.535230316796387
-    *    math.distance([10, 10], [2, 3], [-8, 0])        // Returns 8.759953130362847
+    *    math.distance([0, 0], [3, 0], [0, 4])        // Returns 2.4
     *    math.distance(
-    *     {pointX: 1, pointY: 4},
-    *     {lineOnePtX: 6, lineOnePtY: 3},
-    *     {lineTwoPtX: 2, lineTwoPtY: 8})                // Returns 2.720549372624744
+    *     {pointX: 0, pointY: 0},
+    *     {lineOnePtX: 3, lineOnePtY: 0},
+    *     {lineTwoPtX: 0, lineTwoPtY: 4})                // Returns 2.4
     *    math.distance([2, 3, 1], [1, 1, 2, 5, 0, 1])    // Returns 2.3204774044612857
     *    math.distance(
     *     {pointX: 2, pointY: 3, pointZ: 1},
@@ -55633,10 +55908,12 @@ var createDistance = /* #__PURE__ */factory_factory(distance_name, distance_depe
         if (!_2d(z)) {
           throw new TypeError('Array with 2 numbers or BigNumbers expected for third argument');
         }
-        var m = divideScalar(subtract(z[1], z[0]), subtract(y[1], y[0]));
-        var xCoeff = multiplyScalar(multiplyScalar(m, m), y[0]);
-        var yCoeff = unaryMinus(multiplyScalar(m, y[0]));
-        var constant = x[1];
+        if (deepEqual(y, z)) {
+          throw new TypeError('LinePoint1 should not be same with LinePoint2');
+        }
+        var xCoeff = subtract(z[1], y[1]);
+        var yCoeff = subtract(y[0], z[0]);
+        var constant = subtract(multiplyScalar(z[0], y[1]), multiplyScalar(y[0], z[1]));
         return _distancePointLine2D(x[0], x[1], xCoeff, yCoeff, constant);
       } else {
         throw new TypeError('Invalid Arguments: Try again');
@@ -55653,11 +55930,13 @@ var createDistance = /* #__PURE__ */factory_factory(distance_name, distance_depe
         if (!_2d(z)) {
           throw new TypeError('Values of lineTwoPtX and lineTwoPtY should be numbers or BigNumbers');
         }
+        if (deepEqual(_objectToArray(y), _objectToArray(z))) {
+          throw new TypeError('LinePoint1 should not be same with LinePoint2');
+        }
         if ('pointX' in x && 'pointY' in x && 'lineOnePtX' in y && 'lineOnePtY' in y && 'lineTwoPtX' in z && 'lineTwoPtY' in z) {
-          var m = divideScalar(subtract(z.lineTwoPtY, z.lineTwoPtX), subtract(y.lineOnePtY, y.lineOnePtX));
-          var xCoeff = multiplyScalar(multiplyScalar(m, m), y.lineOnePtX);
-          var yCoeff = unaryMinus(multiplyScalar(m, y.lineOnePtX));
-          var constant = x.pointX;
+          var xCoeff = subtract(z.lineTwoPtY, y.lineOnePtY);
+          var yCoeff = subtract(y.lineOnePtX, z.lineTwoPtX);
+          var constant = subtract(multiplyScalar(z.lineTwoPtX, y.lineOnePtY), multiplyScalar(y.lineOnePtX, z.lineTwoPtY));
           return _distancePointLine2D(x.pointX, x.pointY, xCoeff, yCoeff, constant);
         } else {
           throw new TypeError('Key names do not match');
@@ -57694,7 +57973,7 @@ function permutations_isPositiveInteger(n) {
   return n.isInteger() && n.gte(0);
 }
 // EXTERNAL MODULE: ../../../node_modules/seedrandom/index.js
-var seedrandom = __webpack_require__(11381);
+var seedrandom = __webpack_require__(53775);
 ;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/function/probability/util/seededRNG.js
 
 var singletonRandom = /* #__PURE__ */seedrandom(Date.now());
@@ -58311,7 +58590,7 @@ var createLeafCount = /* #__PURE__ */factory_factory(leafCount_name, leafCount_d
    *
    * Syntax:
    *
-   *     leafCount(expr)
+   *     math.leafCount(expr)
    *
    * Examples:
    *
@@ -58758,13 +59037,13 @@ var createSimplify = /* #__PURE__ */factory_factory(simplify_name, simplify_depe
    *
    * Syntax:
    *
-   *     simplify(expr)
-   *     simplify(expr, rules)
-   *     simplify(expr, rules)
-   *     simplify(expr, rules, scope)
-   *     simplify(expr, rules, scope, options)
-   *     simplify(expr, scope)
-   *     simplify(expr, scope, options)
+   *     math.simplify(expr)
+   *     math.simplify(expr, rules)
+   *     math.simplify(expr, rules)
+   *     math.simplify(expr, rules, scope)
+   *     math.simplify(expr, rules, scope, options)
+   *     math.simplify(expr, scope)
+   *     math.simplify(expr, scope, options)
    *
    * Examples:
    *
@@ -59153,6 +59432,9 @@ var createSimplify = /* #__PURE__ */factory_factory(simplify_name, simplify_depe
   },
   // undo replace 'subtract'
   {
+    l: 'n+-(n1)',
+    r: 'n-(n1)'
+  }, {
     s: 'n*(n1^-1) -> n/n1',
     // undo replace 'divide'; for * commutative
     assuming: {
@@ -59915,8 +60197,8 @@ var createSimplifyConstant = /* #__PURE__ */factory_factory(simplifyConstant_nam
    *
    * Syntax:
    *
-   *     simplifyConstant(expr)
-   *     simplifyConstant(expr, options)
+   *     math.simplifyConstant(expr)
+   *     math.simplifyConstant(expr, options)
    *
    * Examples:
    *
@@ -60401,8 +60683,8 @@ var createSimplifyCore = /* #__PURE__ */factory_factory(simplifyCore_name, simpl
    *
    * Syntax:
    *
-   *     simplifyCore(expr)
-   *     simplifyCore(expr, options)
+   *     math.simplifyCore(expr)
+   *     math.simplifyCore(expr, options)
    *
    * Examples:
    *
@@ -60642,7 +60924,7 @@ var createResolve = /* #__PURE__ */factory_factory(resolve_name, resolve_depende
    *
    * Syntax:
    *
-   *     resolve(expr, scope)
+   *     math.resolve(expr, scope)
    *
    * Examples:
    *
@@ -60748,20 +61030,20 @@ var createSymbolicEqual = /* #__PURE__ */factory_factory(symbolicEqual_name, sym
    *
    * Syntax:
    *
-   *    symbolicEqual(expr1, expr2)
-   *    symbolicEqual(expr1, expr2, options)
+   *     math.symbolicEqual(expr1, expr2)
+   *     math.symbolicEqual(expr1, expr2, options)
    *
    * Examples:
    *
-   *    symbolicEqual('x*y', 'y*x') // Returns true
-   *    symbolicEqual('x*y', 'y*x', {context: {multiply: {commutative: false}}}) // Returns false
-   *    symbolicEqual('x/y', '(y*x^(-1))^(-1)') // Returns true
-   *    symbolicEqual('abs(x)','x') // Returns false
-   *    symbolicEqual('abs(x)','x', simplify.positiveContext) // Returns true
+   *     math.symbolicEqual('x*y', 'y*x') // Returns true
+   *     math.symbolicEqual('x*y', 'y*x', {context: {multiply: {commutative: false}}}) // Returns false
+   *     math.symbolicEqual('x/y', '(y*x^(-1))^(-1)') // Returns true
+   *     math.symbolicEqual('abs(x)','x') // Returns false
+   *     math.symbolicEqual('abs(x)','x', simplify.positiveContext) // Returns true
    *
    * See also:
    *
-   *    simplify, evaluate
+   *     simplify, evaluate
    *
    * @param {Node|string} expr1  The first expression to compare
    * @param {Node|string} expr2  The second expression to compare
@@ -60813,8 +61095,8 @@ var createDerivative = /* #__PURE__ */factory_factory(derivative_name, derivativ
    *
    * Syntax:
    *
-   *     derivative(expr, variable)
-   *     derivative(expr, variable, options)
+   *     math.derivative(expr, variable)
+   *     math.derivative(expr, variable, options)
    *
    * Examples:
    *
@@ -61367,10 +61649,10 @@ var createRationalize = /* #__PURE__ */factory_factory(rationalize_name, rationa
    *
    * Syntax:
    *
-   *     rationalize(expr)
-   *     rationalize(expr, detailed)
-   *     rationalize(expr, scope)
-   *     rationalize(expr, scope, detailed)
+   *     math.rationalize(expr)
+   *     math.rationalize(expr, detailed)
+   *     math.rationalize(expr, scope)
+   *     math.rationalize(expr, scope, detailed)
    *
    * Examples:
    *
@@ -62147,6 +62429,205 @@ var createRationalize = /* #__PURE__ */factory_factory(rationalize_name, rationa
     } // End of recurPol
   } // End of polyToCanonical
 });
+;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/function/signal/zpk2tf.js
+
+var zpk2tf_name = 'zpk2tf';
+var zpk2tf_dependencies = ['typed', 'add', 'multiply', 'Complex', 'number'];
+var createZpk2tf = /* #__PURE__ */factory_factory(zpk2tf_name, zpk2tf_dependencies, _ref => {
+  var {
+    typed,
+    add,
+    multiply,
+    Complex,
+    number
+  } = _ref;
+  /**
+     * Compute the transfer function of a zero-pole-gain model.
+     *
+     * Syntax:
+     *      math.zpk2tf(z, p, k)
+     *
+     * Examples:
+     *    math.zpk2tf([1, 2], [-1, -2], 1)    // returns [[1, -3, 2], [1, 3, 2]]
+     *
+     * See also:
+     *   freqz
+     *
+     * @param {Array} z Array of zeros values
+     * @param {Array} p Array of poles values
+     * @param {number} k Gain value
+     * @return {Array} Two dimensional array containing the numerator (first row) and denominator (second row) polynomials
+     *
+     */
+  return typed(zpk2tf_name, {
+    'Array,Array,number': function ArrayArrayNumber(z, p, k) {
+      return _zpk2tf(z, p, k);
+    },
+    'Array,Array': function ArrayArray(z, p) {
+      return _zpk2tf(z, p, 1);
+    },
+    'Matrix,Matrix,number': function MatrixMatrixNumber(z, p, k) {
+      return _zpk2tf(z.valueOf(), p.valueOf(), k);
+    },
+    'Matrix,Matrix': function MatrixMatrix(z, p) {
+      return _zpk2tf(z.valueOf(), p.valueOf(), 1);
+    }
+  });
+  function _zpk2tf(z, p, k) {
+    // if z is bignumber, convert it to number
+    if (z.some(el => el.type === 'BigNumber')) {
+      z = z.map(el => number(el));
+    }
+    // if p is bignumber, convert it to number
+    if (p.some(el => el.type === 'BigNumber')) {
+      p = p.map(el => number(el));
+    }
+    var num = [Complex(1, 0)];
+    var den = [Complex(1, 0)];
+    for (var i = 0; i < z.length; i++) {
+      var zero = z[i];
+      if (typeof zero === 'number') zero = Complex(zero, 0);
+      num = _multiply(num, [Complex(1, 0), Complex(-zero.re, -zero.im)]);
+    }
+    for (var _i = 0; _i < p.length; _i++) {
+      var pole = p[_i];
+      if (typeof pole === 'number') pole = Complex(pole, 0);
+      den = _multiply(den, [Complex(1, 0), Complex(-pole.re, -pole.im)]);
+    }
+    for (var _i2 = 0; _i2 < num.length; _i2++) {
+      num[_i2] = multiply(num[_i2], k);
+    }
+    return [num, den];
+  }
+  function _multiply(a, b) {
+    var c = [];
+    for (var i = 0; i < a.length + b.length - 1; i++) {
+      c[i] = Complex(0, 0);
+      for (var j = 0; j < a.length; j++) {
+        if (i - j >= 0 && i - j < b.length) {
+          c[i] = add(c[i], multiply(a[j], b[i - j]));
+        }
+      }
+    }
+    return c;
+  }
+});
+;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/function/signal/freqz.js
+
+var freqz_name = 'freqz';
+var freqz_dependencies = ['typed', 'add', 'multiply', 'Complex', 'divide', 'matrix'];
+var createFreqz = /* #__PURE__ */factory_factory(freqz_name, freqz_dependencies, _ref => {
+  var {
+    typed,
+    add,
+    multiply,
+    Complex,
+    divide,
+    matrix
+  } = _ref;
+  /**
+     * Calculates the frequency response of a filter given its numerator and denominator coefficients.
+     *
+     * Syntax:
+     *    math.freqz(b, a)
+     *    math.freqz(b, a, w)
+     *
+     * Examples:
+     *   math.freqz([1, 2], [1, 2, 3], 4) // returns { h: [0.5 + 0i, 0.4768589245763655 + 0.2861153547458193i, 0.25000000000000006 + 0.75i, -0.770976571635189 + 0.4625859429811135i], w: [0, 0.7853981633974483, 1.5707963267948966, 2.356194490192345 ] }
+     *   math.freqz([1, 2], [1, 2, 3], [0, 1]) // returns { h: [0.5 + 0i, 0.45436781 + 0.38598051i], w: [0, 1] }
+     *
+     * See also:
+     *  zpk2tf
+     *
+     * @param {Array.<number>} b The numerator coefficients of the filter.
+     * @param {Array.<number>} a The denominator coefficients of the filter.
+     * @param {Array.<number>} [w] A vector of frequencies (in radians/sample) at which the frequency response is to be computed or the number of points to compute (if a number is not provided, the default is 512 points)
+     * @returns {Object} An object with two properties: h, a vector containing the complex frequency response, and w, a vector containing the normalized frequencies (in radians/sample) at which the response was computed.
+     *
+     *
+     */
+  return typed(freqz_name, {
+    'Array, Array': function ArrayArray(b, a) {
+      var w = createBins(512);
+      return _freqz(b, a, w);
+    },
+    'Array, Array, Array': function ArrayArrayArray(b, a, w) {
+      return _freqz(b, a, w);
+    },
+    'Array, Array, number': function ArrayArrayNumber(b, a, w) {
+      if (w < 0) {
+        throw new Error('w must be a positive number');
+      }
+      var w2 = createBins(w);
+      return _freqz(b, a, w2);
+    },
+    'Matrix, Matrix': function MatrixMatrix(b, a) {
+      // console.log('here')
+      var _w = createBins(512);
+      var {
+        w,
+        h
+      } = _freqz(b.valueOf(), a.valueOf(), _w);
+      return {
+        w: matrix(w),
+        h: matrix(h)
+      };
+    },
+    'Matrix, Matrix, Matrix': function MatrixMatrixMatrix(b, a, w) {
+      var {
+        h
+      } = _freqz(b.valueOf(), a.valueOf(), w.valueOf());
+      return {
+        h: matrix(h),
+        w: matrix(w)
+      };
+    },
+    'Matrix, Matrix, number': function MatrixMatrixNumber(b, a, w) {
+      if (w < 0) {
+        throw new Error('w must be a positive number');
+      }
+      var _w = createBins(w);
+      var {
+        h
+      } = _freqz(b.valueOf(), a.valueOf(), _w);
+      return {
+        h: matrix(h),
+        w: matrix(_w)
+      };
+    }
+  });
+  function _freqz(b, a, w) {
+    var num = [];
+    var den = [];
+    for (var i = 0; i < w.length; i++) {
+      var sumNum = Complex(0, 0);
+      var sumDen = Complex(0, 0);
+      for (var j = 0; j < b.length; j++) {
+        sumNum = add(sumNum, multiply(b[j], Complex(Math.cos(-j * w[i]), Math.sin(-j * w[i]))));
+      }
+      for (var _j = 0; _j < a.length; _j++) {
+        sumDen = add(sumDen, multiply(a[_j], Complex(Math.cos(-_j * w[i]), Math.sin(-_j * w[i]))));
+      }
+      num.push(sumNum);
+      den.push(sumDen);
+    }
+    var h = [];
+    for (var _i = 0; _i < num.length; _i++) {
+      h.push(divide(num[_i], den[_i]));
+    }
+    return {
+      h,
+      w
+    };
+  }
+  function createBins(n) {
+    var bins = [];
+    for (var i = 0; i < n; i++) {
+      bins.push(i / n * Math.PI);
+    }
+    return bins;
+  }
+});
 ;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/json/reviver.js
 
 var reviver_name = 'reviver';
@@ -62198,7 +62679,7 @@ var createReplacer = /* #__PURE__ */factory_factory(replacer_name, replacer_depe
   };
 });
 ;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/version.js
-var version = '11.8.0';
+var version = '11.9.1';
 // Note: This file is automatically generated when building math.js.
 // Changes made in this file will be overwritten.
 ;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/constants.js
@@ -62615,18 +63096,9 @@ var createFilterTransform = /* #__PURE__ */factory_factory(filter_transform_name
  * @private
  */
 function _filter(x, callback) {
-  // figure out what number of arguments the callback function expects
-  var args = maxArgumentCount(callback);
   return filter(x, function (value, index, array) {
     // invoke the callback function with the right number of arguments
-    if (args === 1) {
-      return callback(value);
-    } else if (args === 2) {
-      return callback(value, [index + 1]);
-    } else {
-      // 3 or -1
-      return callback(value, [index + 1], array);
-    }
+    return applyCallback(callback, value, [index + 1], array, 'filter');
   });
 }
 ;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/expression/transform/forEach.transform.js
@@ -62668,8 +63140,6 @@ var createForEachTransform = /* #__PURE__ */factory_factory(forEach_transform_na
   // one-based version of forEach
   var _forEach = typed('forEach', {
     'Array | Matrix, function': function ArrayMatrixFunction(array, callback) {
-      // figure out what number of arguments the callback function expects
-      var args = maxArgumentCount(callback);
       var recurse = function recurse(value, index) {
         if (Array.isArray(value)) {
           forEach(value, function (child, i) {
@@ -62678,14 +63148,7 @@ var createForEachTransform = /* #__PURE__ */factory_factory(forEach_transform_na
           });
         } else {
           // invoke the callback function with the right number of arguments
-          if (args === 1) {
-            callback(value);
-          } else if (args === 2) {
-            callback(value, index);
-          } else {
-            // 3 or -1
-            callback(value, index, array);
-          }
+          return applyCallback(callback, value, index, array, 'forEach');
         }
       };
       recurse(array.valueOf(), []); // pass Array
@@ -62797,7 +63260,7 @@ var createMapTransform = /* #__PURE__ */factory_factory(map_transform_name, map_
 });
 
 /**
- * Map for a multi dimensional array. One-based indexes
+ * Map for a multidimensional array. One-based indexes
  * @param {Array} array
  * @param {function} callback
  * @param {Array} orig
@@ -62805,8 +63268,6 @@ var createMapTransform = /* #__PURE__ */factory_factory(map_transform_name, map_
  * @private
  */
 function map_transform_map(array, callback, orig) {
-  // figure out what number of arguments the callback function expects
-  var argsCount = maxArgumentCount(callback);
   function recurse(value, index) {
     if (Array.isArray(value)) {
       return map(value, function (child, i) {
@@ -62815,14 +63276,7 @@ function map_transform_map(array, callback, orig) {
       });
     } else {
       // invoke the (typed) callback function with the right number of arguments
-      if (argsCount === 1) {
-        return callback(value);
-      } else if (argsCount === 2) {
-        return callback(value, index);
-      } else {
-        // 3 or -1
-        return callback(value, index, orig);
-      }
+      return applyCallback(callback, value, index, orig, 'map');
     }
   }
   return recurse(array, []);
@@ -62970,7 +63424,7 @@ var createMinTransform = /* #__PURE__ */factory_factory(min_transform_name, min_
 
 
 var range_transform_name = 'range';
-var range_transform_dependencies = ['typed', 'config', '?matrix', '?bignumber', 'smaller', 'smallerEq', 'larger', 'largerEq'];
+var range_transform_dependencies = ['typed', 'config', '?matrix', '?bignumber', 'smaller', 'smallerEq', 'larger', 'largerEq', 'add', 'isPositive'];
 var createRangeTransform = /* #__PURE__ */factory_factory(range_transform_name, range_transform_dependencies, _ref => {
   var {
     typed,
@@ -62980,7 +63434,9 @@ var createRangeTransform = /* #__PURE__ */factory_factory(range_transform_name,
     smaller,
     smallerEq,
     larger,
-    largerEq
+    largerEq,
+    add,
+    isPositive
   } = _ref;
   var range = createRange({
     typed,
@@ -62990,7 +63446,9 @@ var createRangeTransform = /* #__PURE__ */factory_factory(range_transform_name,
     smaller,
     smallerEq,
     larger,
-    largerEq
+    largerEq,
+    add,
+    isPositive
   });
 
   /**
@@ -63638,6 +64096,9 @@ var createVarianceTransform = /* #__PURE__ */factory_factory(variance_transform_
 
 
 
+
+
+
 
 
 
@@ -64457,6 +64918,13 @@ var usolve = /* #__PURE__ */createUsolve({
   subtract,
   typed
 });
+var zpk2tf = /* #__PURE__ */createZpk2tf({
+  Complex,
+  add: pureFunctionsAny_generated_add,
+  multiply,
+  number,
+  typed
+});
 var and = /* #__PURE__ */createAnd({
   concat,
   equalScalar,
@@ -64518,12 +64986,12 @@ var diff = /* #__PURE__ */createDiff({
 var distance = /* #__PURE__ */createDistance({
   abs: pureFunctionsAny_generated_abs,
   addScalar,
+  deepEqual,
   divideScalar,
   multiplyScalar,
   sqrt: pureFunctionsAny_generated_sqrt,
   subtract,
-  typed,
-  unaryMinus
+  typed
 });
 var dotMultiply = /* #__PURE__ */createDotMultiply({
   concat,
@@ -64615,7 +65083,9 @@ var qr = /* #__PURE__ */createQr({
 var range = /* #__PURE__ */createRange({
   bignumber,
   matrix,
+  add: pureFunctionsAny_generated_add,
   config: config,
+  isPositive,
   larger,
   largerEq,
   smaller,
@@ -64670,10 +65140,11 @@ var slu = /* #__PURE__ */createSlu({
   transpose,
   typed
 });
-var Spa = /* #__PURE__ */createSpaClass({
-  FibonacciHeap,
-  addScalar,
-  equalScalar
+var sort = /* #__PURE__ */createSort({
+  compare,
+  compareNatural,
+  matrix,
+  typed
 });
 var pureFunctionsAny_generated_sum = /* #__PURE__ */createSum({
   add: pureFunctionsAny_generated_add,
@@ -64736,11 +65207,10 @@ var setSymDifference = /* #__PURE__ */createSetSymDifference({
   subset,
   typed
 });
-var sort = /* #__PURE__ */createSort({
-  compare,
-  compareNatural,
-  matrix,
-  typed
+var Spa = /* #__PURE__ */createSpaClass({
+  FibonacciHeap,
+  addScalar,
+  equalScalar
 });
 var inv = /* #__PURE__ */createInv({
   abs: pureFunctionsAny_generated_abs,
@@ -65072,7 +65542,7 @@ var firstRadiation = /* #__PURE__ */createFirstRadiation({
   Unit,
   config: config
 });
-var gasConstant = /* #__PURE__ */createGasConstant({
+var gravity = /* #__PURE__ */createGravity({
   BigNumber,
   Unit,
   config: config
@@ -65138,6 +65608,23 @@ var setSize = /* #__PURE__ */createSetSize({
   compareNatural,
   typed
 });
+var solveODE = /* #__PURE__ */createSolveODE({
+  abs: pureFunctionsAny_generated_abs,
+  add: pureFunctionsAny_generated_add,
+  bignumber,
+  divide: pureFunctionsAny_generated_divide,
+  isNegative,
+  isPositive,
+  larger,
+  map: pureFunctionsAny_generated_map,
+  matrix,
+  max: pureFunctionsAny_generated_max,
+  multiply,
+  smaller,
+  subtract,
+  typed,
+  unaryMinus
+});
 var stirlingS2 = /* #__PURE__ */createStirlingS2({
   bignumber,
   addScalar,
@@ -65202,22 +65689,11 @@ var fermiCoupling = /* #__PURE__ */createFermiCoupling({
   Unit,
   config: config
 });
-var gravity = /* #__PURE__ */createGravity({
+var gasConstant = /* #__PURE__ */createGasConstant({
   BigNumber,
   Unit,
   config: config
 });
-var kldivergence = /* #__PURE__ */createKldivergence({
-  divide: pureFunctionsAny_generated_divide,
-  dotDivide,
-  isNumeric,
-  log: pureFunctionsAny_generated_log,
-  map: pureFunctionsAny_generated_map,
-  matrix,
-  multiply,
-  sum: pureFunctionsAny_generated_sum,
-  typed
-});
 var mean = /* #__PURE__ */createMean({
   add: pureFunctionsAny_generated_add,
   divide: pureFunctionsAny_generated_divide,
@@ -65259,16 +65735,16 @@ var median = /* #__PURE__ */createMedian({
   partitionSelect,
   typed
 });
-var planckTime = /* #__PURE__ */createPlanckTime({
-  BigNumber,
-  Unit,
-  config: config
-});
-var std = /* #__PURE__ */createStd({
+var kldivergence = /* #__PURE__ */createKldivergence({
+  divide: pureFunctionsAny_generated_divide,
+  dotDivide,
+  isNumeric,
+  log: pureFunctionsAny_generated_log,
   map: pureFunctionsAny_generated_map,
-  sqrt: pureFunctionsAny_generated_sqrt,
-  typed,
-  variance
+  matrix,
+  multiply,
+  sum: pureFunctionsAny_generated_sum,
+  typed
 });
 var mad = /* #__PURE__ */createMad({
   abs: pureFunctionsAny_generated_abs,
@@ -65277,6 +65753,20 @@ var mad = /* #__PURE__ */createMad({
   subtract,
   typed
 });
+var std = /* #__PURE__ */createStd({
+  map: pureFunctionsAny_generated_map,
+  sqrt: pureFunctionsAny_generated_sqrt,
+  typed,
+  variance
+});
+var freqz = /* #__PURE__ */createFreqz({
+  Complex,
+  add: pureFunctionsAny_generated_add,
+  divide: pureFunctionsAny_generated_divide,
+  matrix,
+  multiply,
+  typed
+});
 var norm = /* #__PURE__ */createNorm({
   abs: pureFunctionsAny_generated_abs,
   add: pureFunctionsAny_generated_add,
@@ -65306,10 +65796,10 @@ var rotationMatrix = /* #__PURE__ */createRotationMatrix({
   typed,
   unaryMinus
 });
-var rotate = /* #__PURE__ */createRotate({
-  multiply,
-  rotationMatrix,
-  typed
+var planckTime = /* #__PURE__ */createPlanckTime({
+  BigNumber,
+  Unit,
+  config: config
 });
 var schur = /* #__PURE__ */createSchur({
   identity,
@@ -65320,6 +65810,11 @@ var schur = /* #__PURE__ */createSchur({
   subtract,
   typed
 });
+var rotate = /* #__PURE__ */createRotate({
+  multiply,
+  rotationMatrix,
+  typed
+});
 var sylvester = /* #__PURE__ */createSylvester({
   abs: pureFunctionsAny_generated_abs,
   add: pureFunctionsAny_generated_add,
@@ -65474,15 +65969,12 @@ var compile = createCompile({
   parse,
   typed: typed
 });
-var evaluate = createEvaluate({
-  parse,
-  typed: typed
-});
 var Help = createHelpClass({
   parse
 });
-var Parser = createParserClass({
-  evaluate
+var leafCount = createLeafCount({
+  parse,
+  typed: typed
 });
 var simplifyCore = createSimplifyCore({
   AccessorNode,
@@ -65504,11 +65996,18 @@ var simplifyCore = createSimplifyCore({
   subtract: subtract,
   typed: typed
 });
+var evaluate = createEvaluate({
+  parse,
+  typed: typed
+});
 var help = createHelp({
   Help,
   mathWithTransform,
   typed: typed
 });
+var Parser = createParserClass({
+  evaluate
+});
 var simplify = createSimplify({
   bignumber: bignumber,
   fraction: pureFunctionsAny_generated_fraction,
@@ -65561,10 +66060,6 @@ var parser = createParser({
   Parser,
   typed: typed
 });
-var leafCount = createLeafCount({
-  parse,
-  typed: typed
-});
 var rationalize = createRationalize({
   bignumber: bignumber,
   fraction: pureFunctionsAny_generated_fraction,
@@ -65764,6 +66259,7 @@ var rationalize = createRationalize({
   subtract: subtract,
   trace: trace,
   usolve: usolve,
+  zpk2tf: zpk2tf,
   and: and,
   bitOr: bitOr,
   ceil: pureFunctionsAny_generated_ceil,
@@ -65789,6 +66285,7 @@ var rationalize = createRationalize({
   setIsSubset: setIsSubset,
   setPowerset: setPowerset,
   slu: slu,
+  sort: sort,
   sum: pureFunctionsAny_generated_sum,
   usolveAll: usolveAll,
   atan2: pureFunctionsAny_generated_atan2,
@@ -65797,7 +66294,6 @@ var rationalize = createRationalize({
   setDifference: setDifference,
   setMultiplicity: setMultiplicity,
   setSymDifference: setSymDifference,
-  sort: sort,
   inv: inv,
   lup: lup,
   pinv: pinv,
@@ -65847,50 +66343,52 @@ var rationalize = createRationalize({
   electronMass: electronMass,
   factorial: factorial,
   firstRadiation: firstRadiation,
-  gasConstant: gasConstant,
+  gravity: gravity,
   inverseConductanceQuantum: inverseConductanceQuantum,
   lusolve: lusolve,
   magneticFluxQuantum: magneticFluxQuantum,
   molarMassC12: molarMassC12,
   multinomial: multinomial,
+  parse,
   permutations: permutations,
   planckMass: planckMass,
   polynomialRoot: polynomialRoot,
+  resolve,
   setSize: setSize,
+  simplifyConstant,
+  solveODE: solveODE,
   stirlingS2: stirlingS2,
   unit: unit,
   bellNumbers: bellNumbers,
+  compile,
   eigs: eigs,
   fermiCoupling: fermiCoupling,
-  gravity: gravity,
-  kldivergence: kldivergence,
+  gasConstant: gasConstant,
+  leafCount,
   mean: mean,
   molarVolume: molarVolume,
   planckConstant: planckConstant,
   quantumOfCirculation: quantumOfCirculation,
+  simplifyCore,
   variance: variance,
   classicalElectronRadius: classicalElectronRadius,
-  median: median,
-  parse,
-  planckTime: planckTime,
-  resolve,
-  simplifyConstant,
-  std: std,
-  compile,
   evaluate,
-  mad: mad,
-  simplifyCore,
   help,
-  norm: norm,
-  rotationMatrix: rotationMatrix,
+  median: median,
   simplify,
   symbolicEqual,
   derivative,
+  kldivergence: kldivergence,
+  mad: mad,
   parser,
-  rotate: rotate,
-  leafCount,
   rationalize,
+  std: std,
+  freqz: freqz,
+  norm: norm,
+  rotationMatrix: rotationMatrix,
+  planckTime: planckTime,
   schur: schur,
+  rotate: rotate,
   sylvester: sylvester,
   lyap: lyap,
   config: config
@@ -65954,7 +66452,9 @@ var rationalize = createRationalize({
   range: createRangeTransform({
     bignumber: bignumber,
     matrix: matrix,
+    add: pureFunctionsAny_generated_add,
     config: config,
+    isPositive: isPositive,
     larger: larger,
     largerEq: largerEq,
     smaller: smaller,
@@ -67419,6 +67919,17 @@ var IndexDependencies = {
   ImmutableDenseMatrixDependencies: ImmutableDenseMatrixDependencies,
   createIndexClass: createIndexClass
 };
+;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/entry/dependenciesAny/dependenciesIsPositive.generated.js
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+
+var isPositiveDependencies = {
+  typedDependencies: typedDependencies,
+  createIsPositive: createIsPositive
+};
 ;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/entry/dependenciesAny/dependenciesLargerEq.generated.js
 /**
  * THIS FILE IS AUTO-GENERATED
@@ -67466,9 +67977,13 @@ var smallerEqDependencies = {
 
 
 
+
+
 var rangeDependencies = {
   bignumberDependencies: bignumberDependencies,
   matrixDependencies: matrixDependencies,
+  addDependencies: addDependencies,
+  isPositiveDependencies: isPositiveDependencies,
   largerDependencies: largerDependencies,
   largerEqDependencies: largerEqDependencies,
   smallerDependencies: smallerDependencies,
@@ -67770,17 +68285,6 @@ var complexDependencies = {
   typedDependencies: typedDependencies,
   createComplex: createComplex
 };
-;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/entry/dependenciesAny/dependenciesIsPositive.generated.js
-/**
- * THIS FILE IS AUTO-GENERATED
- * DON'T MAKE CHANGES HERE
- */
-
-
-var isPositiveDependencies = {
-  typedDependencies: typedDependencies,
-  createIsPositive: createIsPositive
-};
 ;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/entry/dependenciesAny/dependenciesComposition.generated.js
 /**
  * THIS FILE IS AUTO-GENERATED
@@ -68378,12 +68882,12 @@ var sqrtDependencies = {
 var distanceDependencies = {
   absDependencies: absDependencies,
   addScalarDependencies: addScalarDependencies,
+  deepEqualDependencies: deepEqualDependencies,
   divideScalarDependencies: divideScalarDependencies,
   multiplyScalarDependencies: multiplyScalarDependencies,
   sqrtDependencies: sqrtDependencies,
   subtractDependencies: subtractDependencies,
   typedDependencies: typedDependencies,
-  unaryMinusDependencies: unaryMinusDependencies,
   createDistance: createDistance
 };
 ;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/entry/dependenciesAny/dependenciesDotDivide.generated.js
@@ -69012,6 +69516,27 @@ var forEachTransformDependencies = {
   typedDependencies: typedDependencies,
   createForEachTransform: createForEachTransform
 };
+;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/entry/dependenciesAny/dependenciesFreqz.generated.js
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+
+
+
+
+
+
+var freqzDependencies = {
+  ComplexDependencies: ComplexDependencies,
+  addDependencies: addDependencies,
+  divideDependencies: divideDependencies,
+  matrixDependencies: matrixDependencies,
+  multiplyDependencies: multiplyDependencies,
+  typedDependencies: typedDependencies,
+  createFreqz: createFreqz
+};
 ;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/entry/dependenciesAny/dependenciesGasConstant.generated.js
 /**
  * THIS FILE IS AUTO-GENERATED
@@ -70623,9 +71148,13 @@ var RangeDependencies = {
 
 
 
+
+
 var rangeTransformDependencies = {
   bignumberDependencies: bignumberDependencies,
   matrixDependencies: matrixDependencies,
+  addDependencies: addDependencies,
+  isPositiveDependencies: isPositiveDependencies,
   largerDependencies: largerDependencies,
   largerEqDependencies: largerEqDependencies,
   smallerDependencies: smallerDependencies,
@@ -71165,6 +71694,45 @@ var sinhDependencies = {
   typedDependencies: typedDependencies,
   createSinh: createSinh
 };
+;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/entry/dependenciesAny/dependenciesSolveODE.generated.js
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var solveODEDependencies = {
+  absDependencies: absDependencies,
+  addDependencies: addDependencies,
+  bignumberDependencies: bignumberDependencies,
+  divideDependencies: divideDependencies,
+  isNegativeDependencies: isNegativeDependencies,
+  isPositiveDependencies: isPositiveDependencies,
+  largerDependencies: largerDependencies,
+  mapDependencies: mapDependencies,
+  matrixDependencies: matrixDependencies,
+  maxDependencies: maxDependencies,
+  multiplyDependencies: multiplyDependencies,
+  smallerDependencies: smallerDependencies,
+  subtractDependencies: subtractDependencies,
+  typedDependencies: typedDependencies,
+  unaryMinusDependencies: unaryMinusDependencies,
+  createSolveODE: createSolveODE
+};
 ;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/entry/dependenciesAny/dependenciesSort.generated.js
 /**
  * THIS FILE IS AUTO-GENERATED
@@ -71614,6 +72182,25 @@ var xorDependencies = {
   typedDependencies: typedDependencies,
   createXor: createXor
 };
+;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/entry/dependenciesAny/dependenciesZpk2tf.generated.js
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+
+
+
+
+
+
+var zpk2tfDependencies = {
+  ComplexDependencies: ComplexDependencies,
+  addDependencies: addDependencies,
+  multiplyDependencies: multiplyDependencies,
+  numberDependencies: numberDependencies,
+  typedDependencies: typedDependencies,
+  createZpk2tf: createZpk2tf
+};
 ;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/entry/allFactoriesAny.js
 // creating all factories here in a separate file is needed to get tree-shaking working
 
@@ -71892,6 +72479,7 @@ var allFactoriesAny_all = (/* unused pure expression or super */ null && (allFac
 
 
 
+
 
 
  // eslint-disable-line camelcase
@@ -71970,11 +72558,13 @@ var allFactoriesAny_all = (/* unused pure expression or super */ null && (allFac
 
 
 
+
+
 
 
 
 // EXTERNAL MODULE: ../../../node_modules/tiny-emitter/index.js
-var tiny_emitter = __webpack_require__(90567);
+var tiny_emitter = __webpack_require__(89757);
 ;// CONCATENATED MODULE: ../../../node_modules/mathjs/lib/esm/utils/emitter.js